Source for file component.php

Documentation is available at component.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.  * Component installer
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Installer
  20.  * @since       3.1
  21.  */
  22. class JInstallerAdapterComponent extends JAdapterInstance
  23. {
  24.     /**
  25.      * Copy of the XML manifest file
  26.      *
  27.      * @var    string 
  28.      * @since  3.1
  29.      */
  30.     protected $manifest = null;
  31.  
  32.     /**
  33.      * Name of the extension
  34.      *
  35.      * @var    string 
  36.      * @since  3.1
  37.      *  */
  38.     protected $name = null;
  39.  
  40.     /**
  41.      * The unique identifier for the extension (e.g. mod_login)
  42.      *
  43.      * @var    string 
  44.      * @since  3.1
  45.      *  */
  46.     protected $element = null;
  47.  
  48.     /**
  49.      * The list of current files fo the Joomla! CMS administrator that are installed and is read
  50.      * from the manifest on disk in the update area to handle doing a diff
  51.      * and deleting files that are in the old files list and not in the new
  52.      * files list.
  53.      *
  54.      * @var    array 
  55.      * @since  3.1
  56.      *  */
  57.     protected $oldAdminFiles = null;
  58.  
  59.     /**
  60.      * The list of current files that are installed and is read
  61.      * from the manifest on disk in the update area to handle doing a diff
  62.      * and deleting files that are in the old files list and not in the new
  63.      * files list.
  64.      *
  65.      * @var    array 
  66.      * @since  3.1
  67.      *  */
  68.     protected $oldFiles = null;
  69.  
  70.     /**
  71.      * A path to the PHP file that the scriptfile declaration in
  72.      * the manifest refers to.
  73.      *
  74.      * @var    string 
  75.      * @since  3.1
  76.      *  */
  77.     protected $manifest_script = null;
  78.  
  79.     /**
  80.      * For legacy installations this is a path to the PHP file that the scriptfile declaration in the
  81.      * manifest refers to.
  82.      *
  83.      * @var    string 
  84.      * @since  3.1
  85.      *  */
  86.     protected $install_script = null;
  87.  
  88.     /**
  89.      * Custom loadLanguage method
  90.      *
  91.      * @param   string  $path  The path language files are on.
  92.      *
  93.      * @return  void 
  94.      *
  95.      * @since   3.1
  96.      */
  97.     public function loadLanguage($path = null)
  98.     {
  99.         $source = $this->parent->getPath('source');
  100.  
  101.         if (!$source)
  102.         {
  103.             $this->parent
  104.                 ->setPath(
  105.                 'source',
  106.                 ($this->parent->extension->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) .
  107.                 '/components/' . $this->parent->extension->element
  108.             );
  109.         }
  110.  
  111.         $this->manifest = $this->parent->getManifest();
  112.         $name = strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  113.  
  114.         if (substr($name, 0, 4) == 'com_')
  115.         {
  116.             $extension = $name;
  117.         }
  118.         else
  119.         {
  120.             $extension = 'com_' . $name;
  121.         }
  122.  
  123.         $lang = JFactory::getLanguage();
  124.         $source = $path ? $path : ($this->parent->extension->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) . '/components/' . $extension;
  125.  
  126.         if ($this->manifest->administration->files)
  127.         {
  128.             $element = $this->manifest->administration->files;
  129.         }
  130.         elseif ($this->manifest->files)
  131.         {
  132.             $element = $this->manifest->files;
  133.         }
  134.         else
  135.         {
  136.             $element = null;
  137.         }
  138.  
  139.         if ($element)
  140.         {
  141.             $folder = (string) $element->attributes()->folder;
  142.  
  143.             if ($folder && file_exists($path . '/' . $folder))
  144.             {
  145.                 $source = $path . '/' . $folder;
  146.             }
  147.         }
  148.         $lang->load($extension . '.sys', $source, null, false, true) || $lang->load($extension . '.sys', JPATH_ADMINISTRATOR, null, false, true);
  149.     }
  150.  
  151.     /**
  152.      * Custom install method for components
  153.      *
  154.      * @return  boolean  True on success
  155.      *
  156.      * @since   3.1
  157.      */
  158.     public function install()
  159.     {
  160.         // Get a database connector object
  161.         $db = $this->parent->getDbo();
  162.  
  163.         // Get the extension manifest object
  164.         $this->manifest = $this->parent->getManifest();
  165.  
  166.         /*
  167.          * ---------------------------------------------------------------------------------------------
  168.          * Manifest Document Setup Section
  169.          * ---------------------------------------------------------------------------------------------
  170.          */
  171.  
  172.         // Set the extension's name
  173.         $name = strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  174.  
  175.         if (substr($name, 0, 4) == 'com_')
  176.         {
  177.             $element = $name;
  178.         }
  179.         else
  180.         {
  181.             $element = 'com_' . $name;
  182.         }
  183.  
  184.         $this->set('name', $name);
  185.         $this->set('element', $element);
  186.  
  187.         // Get the component description
  188.         $this->parent->set('message', JText::_((string) $this->manifest->description));
  189.  
  190.         // Set the installation target paths
  191.         $this->parent->setPath('extension_site', JPath::clean(JPATH_SITE . '/components/' . $this->get('element')));
  192.         $this->parent->setPath('extension_administrator', JPath::clean(JPATH_ADMINISTRATOR . '/components/' . $this->get('element')));
  193.  
  194.         // Copy the admin path as it's used as a common base
  195.         $this->parent->setPath('extension_root', $this->parent->getPath('extension_administrator'));
  196.  
  197.         /*
  198.          * ---------------------------------------------------------------------------------------------
  199.          * Basic Checks Section
  200.          * ---------------------------------------------------------------------------------------------
  201.          */
  202.  
  203.         // Make sure that we have an admin element
  204.         if (!$this->manifest->administration)
  205.         {
  206.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_INSTALL_ADMIN_ELEMENT'), JLog::WARNING, 'jerror');
  207.  
  208.             return false;
  209.         }
  210.  
  211.         /*
  212.          * ---------------------------------------------------------------------------------------------
  213.          * Filesystem Processing Section
  214.          * ---------------------------------------------------------------------------------------------
  215.          */
  216.  
  217.         /*
  218.          * If the component site or admin directory already exists, then we will assume that the component is already
  219.          * installed or another component is using that directory.
  220.          */
  221.  
  222.         if (file_exists($this->parent->getPath('extension_site')) || file_exists($this->parent->getPath('extension_administrator')))
  223.         {
  224.             // Look for an update function or update tag
  225.             $updateElement = $this->manifest->update;
  226.  
  227.             // Upgrade manually set or update function available or update tag detected
  228.             if ($this->parent->isUpgrade() || ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'update'))
  229.                 || $updateElement)
  230.             {
  231.                 // Transfer control to the update function
  232.                 return $this->update();
  233.             }
  234.             elseif (!$this->parent->isOverwrite())
  235.             {
  236.                 // Overwrite is set.
  237.                 // We didn't have overwrite set, find an update function or find an update tag so lets call it safe
  238.                 if (file_exists($this->parent->getPath('extension_site')))
  239.                 {
  240.                     // If the site exists say so.
  241.                     JLog::add(
  242.                         JText::sprintf('JLIB_INSTALLER_ERROR_COMP_INSTALL_DIR_SITE', $this->parent->getPath('extension_site')),
  243.                         JLog::WARNING, 'jerror'
  244.                     );
  245.                 }
  246.                 else
  247.                 {
  248.                     // If the admin exists say so
  249.                     JLog::add(
  250.                         JText::sprintf('JLIB_INSTALLER_ERROR_COMP_INSTALL_DIR_ADMIN', $this->parent->getPath('extension_administrator')),
  251.                         JLog::WARNING, 'jerror'
  252.                     );
  253.                 }
  254.                 return false;
  255.             }
  256.         }
  257.  
  258.         /*
  259.          * ---------------------------------------------------------------------------------------------
  260.          * Installer Trigger Loading
  261.          * ---------------------------------------------------------------------------------------------
  262.          */
  263.  
  264.         // If there is an manifest class file, lets load it; we'll copy it later (don't have dest yet)
  265.         $manifestScript = (string) $this->manifest->scriptfile;
  266.  
  267.         if ($manifestScript)
  268.         {
  269.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  270.  
  271.             if (is_file($manifestScriptFile))
  272.             {
  273.                 // Load the file
  274.                 include_once $manifestScriptFile;
  275.             }
  276.  
  277.             // Set the class name
  278.             $classname = $this->get('element') . 'InstallerScript';
  279.  
  280.             if (class_exists($classname))
  281.             {
  282.                 // Create a new instance
  283.                 $this->parent->manifestClass = new $classname($this);
  284.  
  285.                 // And set this so we can copy it later
  286.                 $this->set('manifest_script', $manifestScript);
  287.             }
  288.         }
  289.  
  290.         // Run preflight if possible (since we know we're not an update)
  291.         ob_start();
  292.         ob_implicit_flush(false);
  293.  
  294.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  295.         {
  296.             if ($this->parent->manifestClass->preflight('install', $this) === false)
  297.             {
  298.                 // Install failed, rollback changes
  299.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  300.  
  301.                 return false;
  302.             }
  303.         }
  304.  
  305.         // Create msg object; first use here
  306.         $msg = ob_get_contents();
  307.         ob_end_clean();
  308.  
  309.         // If the component directory does not exist, let's create it
  310.         $created = false;
  311.  
  312.         if (!file_exists($this->parent->getPath('extension_site')))
  313.         {
  314.             if (!$created = JFolder::create($this->parent->getPath('extension_site')))
  315.             {
  316.                 JLog::add(
  317.                     JText::sprintf('JLIB_INSTALLER_ERROR_COMP_INSTALL_FAILED_TO_CREATE_DIRECTORY_SITE', $this->parent->getPath('extension_site')),
  318.                     JLog::WARNING, 'jerror'
  319.                 );
  320.  
  321.                 return false;
  322.             }
  323.         }
  324.  
  325.         /*
  326.          * Since we created the component directory and we will want to remove it if we have to roll back
  327.          * the installation, let's add it to the installation step stack
  328.          */
  329.         if ($created)
  330.         {
  331.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_site')));
  332.         }
  333.  
  334.         // If the component admin directory does not exist, let's create it
  335.         $created = false;
  336.  
  337.         if (!file_exists($this->parent->getPath('extension_administrator')))
  338.         {
  339.             if (!$created = JFolder::create($this->parent->getPath('extension_administrator')))
  340.             {
  341.                 JLog::add(
  342.                     JText::sprintf('JLIB_INSTALLER_ERROR_COMP_INSTALL_FAILED_TO_CREATE_DIRECTORY_ADMIN', $this->parent->getPath('extension_administrator')),
  343.                     JLog::WARNING, 'jerror'
  344.                 );
  345.  
  346.                 // Install failed, rollback any changes
  347.                 $this->parent->abort();
  348.  
  349.                 return false;
  350.             }
  351.         }
  352.  
  353.         /*
  354.          * Since we created the component admin directory and we will want to remove it if we have to roll
  355.          * back the installation, let's add it to the installation step stack
  356.          */
  357.         if ($created)
  358.         {
  359.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_administrator')));
  360.         }
  361.  
  362.         // Copy site files
  363.         if ($this->manifest->files)
  364.         {
  365.             if ($this->parent->parseFiles($this->manifest->files) === false)
  366.             {
  367.                 // Install failed, rollback any changes
  368.                 $this->parent->abort();
  369.  
  370.                 return false;
  371.             }
  372.         }
  373.  
  374.         // Copy admin files
  375.         if ($this->manifest->administration->files)
  376.         {
  377.             if ($this->parent->parseFiles($this->manifest->administration->files, 1) === false)
  378.             {
  379.                 // Install failed, rollback any changes
  380.                 $this->parent->abort();
  381.  
  382.                 return false;
  383.             }
  384.         }
  385.  
  386.         // Parse optional tags
  387.         $this->parent->parseMedia($this->manifest->media);
  388.         $this->parent->parseLanguages($this->manifest->languages);
  389.         $this->parent->parseLanguages($this->manifest->administration->languages, 1);
  390.  
  391.         // If there is a manifest script, let's copy it.
  392.         if ($this->get('manifest_script'))
  393.         {
  394.             $path['src'] = $this->parent->getPath('source') . '/' . $this->get('manifest_script');
  395.             $path['dest'] = $this->parent->getPath('extension_administrator') . '/' . $this->get('manifest_script');
  396.  
  397.             if (!file_exists($path['dest']) || $this->parent->isOverwrite())
  398.             {
  399.                 if (!$this->parent->copyFiles(array($path)))
  400.                 {
  401.                     // Install failed, rollback changes
  402.                     $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_MANIFEST'));
  403.  
  404.                     return false;
  405.                 }
  406.             }
  407.         }
  408.  
  409.         /*
  410.          * ---------------------------------------------------------------------------------------------
  411.          * Database Processing Section
  412.          * ---------------------------------------------------------------------------------------------
  413.          */
  414.  
  415.         // Run the install queries for the component
  416.         if (isset($this->manifest->install->sql))
  417.         {
  418.             $result = $this->parent->parseSQLFiles($this->manifest->install->sql);
  419.  
  420.             if ($result === false)
  421.             {
  422.                 // Install failed, rollback changes
  423.                 $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_SQL_ERROR', $db->stderr(true)));
  424.  
  425.                 return false;
  426.             }
  427.         }
  428.  
  429.         /**
  430.          * ---------------------------------------------------------------------------------------------
  431.          * Custom Installation Script Section
  432.          * ---------------------------------------------------------------------------------------------
  433.          */
  434.  
  435.         /*
  436.          * If we have an install script, let's include it, execute the custom
  437.          * install method, and append the return value from the custom install
  438.          * method to the installation message.
  439.          */
  440.         ob_start();
  441.         ob_implicit_flush(false);
  442.  
  443.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'install'))
  444.         {
  445.             if ($this->parent->manifestClass->install($this) === false)
  446.             {
  447.                 // Install failed, rollback changes
  448.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  449.  
  450.                 return false;
  451.             }
  452.         }
  453.  
  454.         // Append messages
  455.         $msg .= ob_get_contents();
  456.         ob_end_clean();
  457.  
  458.         /**
  459.          * ---------------------------------------------------------------------------------------------
  460.          * Finalization and Cleanup Section
  461.          * ---------------------------------------------------------------------------------------------
  462.          */
  463.  
  464.         // Add an entry to the extension table with a whole heap of defaults
  465.         $row = JTable::getInstance('extension');
  466.         $row->set('name', $this->get('name'));
  467.         $row->set('type', 'component');
  468.         $row->set('element', $this->get('element'));
  469.  
  470.         // There is no folder for components
  471.         $row->set('folder', '');
  472.         $row->set('enabled', 1);
  473.         $row->set('protected', 0);
  474.         $row->set('access', 0);
  475.         $row->set('client_id', 1);
  476.         $row->set('params', $this->parent->getParams());
  477.         $row->set('manifest_cache', $this->parent->generateManifestCache());
  478.  
  479.         if (!$row->store())
  480.         {
  481.             // Install failed, roll back changes
  482.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_ROLLBACK', $db->stderr(true)));
  483.  
  484.             return false;
  485.         }
  486.  
  487.         $eid = $row->extension_id;
  488.  
  489.         // Clobber any possible pending updates
  490.         $update = JTable::getInstance('update');
  491.         $uid = $update->find(array('element' => $this->get('element'), 'type' => 'component', 'client_id' => 1, 'folder' => ''));
  492.  
  493.         if ($uid)
  494.         {
  495.             $update->delete($uid);
  496.         }
  497.  
  498.         // We will copy the manifest file to its appropriate place.
  499.         if (!$this->parent->copyManifest())
  500.         {
  501.             // Install failed, rollback changes
  502.             $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_COPY_SETUP'));
  503.  
  504.             return false;
  505.         }
  506.  
  507.         // Time to build the admin menus
  508.         if (!$this->_buildAdminMenus($row->extension_id))
  509.         {
  510.             JLog::add(JText::_('JLIB_INSTALLER_ABORT_COMP_BUILDADMINMENUS_FAILED'), JLog::WARNING, 'jerror');
  511.  
  512.             // @todo remove code: $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_ROLLBACK', $db->stderr(true)));
  513.             // @todo remove code: return false;
  514.         }
  515.  
  516.         // Set the schema version to be the latest update version
  517.         if ($this->manifest->update)
  518.         {
  519.             $this->parent->setSchemaVersion($this->manifest->update->schemas, $eid);
  520.         }
  521.  
  522.         // Register the component container just under root in the assets table.
  523.         $asset = JTable::getInstance('Asset');
  524.         $asset->name = $row->element;
  525.         $asset->parent_id = 1;
  526.         $asset->rules = '{}';
  527.         $asset->title = $row->name;
  528.         $asset->setLocation(1, 'last-child');
  529.  
  530.         if (!$asset->store())
  531.         {
  532.             // Install failed, roll back changes
  533.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_ROLLBACK', $db->stderr(true)));
  534.  
  535.             return false;
  536.         }
  537.  
  538.         // And now we run the postflight
  539.         ob_start();
  540.         ob_implicit_flush(false);
  541.  
  542.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'postflight'))
  543.         {
  544.             $this->parent->manifestClass->postflight('install', $this);
  545.         }
  546.  
  547.         // Append messages
  548.         $msg .= ob_get_contents();
  549.         ob_end_clean();
  550.  
  551.         if ($msg != '')
  552.         {
  553.             $this->parent->set('extension_message', $msg);
  554.         }
  555.  
  556.         return $row->extension_id;
  557.     }
  558.  
  559.     /**
  560.      * Custom update method for components
  561.      *
  562.      * @return  boolean  True on success
  563.      *
  564.      * @since   3.1
  565.      */
  566.     public function update()
  567.     {
  568.         // Get a database connector object
  569.         $db = $this->parent->getDbo();
  570.  
  571.         // Set the overwrite setting
  572.         $this->parent->setOverwrite(true);
  573.  
  574.         // Get the extension manifest object
  575.         $this->manifest = $this->parent->getManifest();
  576.  
  577.         /**
  578.          * ---------------------------------------------------------------------------------------------
  579.          * Manifest Document Setup Section
  580.          * ---------------------------------------------------------------------------------------------
  581.          */
  582.  
  583.         // Set the extension's name
  584.         $name = strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  585.  
  586.         if (substr($name, 0, 4) == 'com_')
  587.         {
  588.             $element = $name;
  589.         }
  590.         else
  591.         {
  592.             $element = 'com_' . $name;
  593.         }
  594.  
  595.         $this->set('name', $name);
  596.         $this->set('element', $element);
  597.  
  598.         // Get the component description
  599.         $description = (string) $this->manifest->description;
  600.  
  601.         if ($description)
  602.         {
  603.             $this->parent->set('message', JText::_($description));
  604.         }
  605.         else
  606.         {
  607.             $this->parent->set('message', '');
  608.         }
  609.  
  610.         // Set the installation target paths
  611.         $this->parent->setPath('extension_site', JPath::clean(JPATH_SITE . '/components/' . $this->get('element')));
  612.         $this->parent->setPath('extension_administrator', JPath::clean(JPATH_ADMINISTRATOR . '/components/' . $this->get('element')));
  613.  
  614.         // Copy the admin path as it's used as a common base
  615.         $this->parent->setPath('extension_root', $this->parent->getPath('extension_administrator'));
  616.  
  617.         // Hunt for the original XML file
  618.         $old_manifest = null;
  619.  
  620.         // Create a new installer because findManifest sets stuff
  621.         // Look in the administrator first
  622.         $tmpInstaller = new JInstaller;
  623.         $tmpInstaller->setPath('source', $this->parent->getPath('extension_administrator'));
  624.  
  625.         if (!$tmpInstaller->findManifest())
  626.         {
  627.             // Then the site
  628.             $tmpInstaller->setPath('source', $this->parent->getPath('extension_site'));
  629.  
  630.             if ($tmpInstaller->findManifest())
  631.             {
  632.                 $old_manifest = $tmpInstaller->getManifest();
  633.             }
  634.         }
  635.         else
  636.         {
  637.             $old_manifest = $tmpInstaller->getManifest();
  638.         }
  639.  
  640.         // Should do this above perhaps?
  641.         if ($old_manifest)
  642.         {
  643.             $this->oldAdminFiles = $old_manifest->administration->files;
  644.             $this->oldFiles = $old_manifest->files;
  645.         }
  646.         else
  647.         {
  648.             $this->oldAdminFiles = null;
  649.             $this->oldFiles = null;
  650.         }
  651.  
  652.         /**
  653.          * ---------------------------------------------------------------------------------------------
  654.          * Basic Checks Section
  655.          * ---------------------------------------------------------------------------------------------
  656.          */
  657.  
  658.         // Make sure that we have an admin element
  659.         if (!$this->manifest->administration)
  660.         {
  661.             JLog::add(JText::_('JLIB_INSTALLER_ABORT_COMP_UPDATE_ADMIN_ELEMENT'), JLog::WARNING, 'jerror');
  662.  
  663.             return false;
  664.         }
  665.  
  666.         /**
  667.          * ---------------------------------------------------------------------------------------------
  668.          * Installer Trigger Loading
  669.          * ---------------------------------------------------------------------------------------------
  670.          */
  671.  
  672.         // If there is an manifest class file, lets load it; we'll copy it later (don't have dest yet)
  673.         $manifestScript = (string) $this->manifest->scriptfile;
  674.  
  675.         if ($manifestScript)
  676.         {
  677.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  678.  
  679.             if (is_file($manifestScriptFile))
  680.             {
  681.                 // Load the file
  682.                 include_once $manifestScriptFile;
  683.             }
  684.  
  685.             // Set the class name
  686.             $classname = $element . 'InstallerScript';
  687.  
  688.             if (class_exists($classname))
  689.             {
  690.                 // Create a new instance
  691.                 $this->parent->manifestClass = new $classname($this);
  692.  
  693.                 // And set this so we can copy it later
  694.                 $this->set('manifest_script', $manifestScript);
  695.             }
  696.         }
  697.  
  698.         // Run preflight if possible (since we know we're not an update)
  699.         ob_start();
  700.         ob_implicit_flush(false);
  701.  
  702.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  703.         {
  704.             if ($this->parent->manifestClass->preflight('update', $this) === false)
  705.             {
  706.                 // Install failed, rollback changes
  707.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  708.  
  709.                 return false;
  710.             }
  711.         }
  712.  
  713.         // Create msg object; first use here
  714.         $msg = ob_get_contents();
  715.         ob_end_clean();
  716.  
  717.         /**
  718.          * ---------------------------------------------------------------------------------------------
  719.          * Filesystem Processing Section
  720.          * ---------------------------------------------------------------------------------------------
  721.          */
  722.  
  723.         // If the component directory does not exist, let's create it
  724.         $created = false;
  725.  
  726.         if (!file_exists($this->parent->getPath('extension_site')))
  727.         {
  728.             if (!$created = JFolder::create($this->parent->getPath('extension_site')))
  729.             {
  730.                 JLog::add(
  731.                     JText::sprintf('JLIB_INSTALLER_ERROR_COMP_UPDATE_FAILED_TO_CREATE_DIRECTORY_SITE', $this->parent->getPath('extension_site')),
  732.                     JLog::WARNING, 'jerror'
  733.                 );
  734.  
  735.                 return false;
  736.             }
  737.         }
  738.  
  739.         /*
  740.          * Since we created the component directory and will want to remove it if we have to roll back
  741.          * the installation, lets add it to the installation step stack
  742.          */
  743.         if ($created)
  744.         {
  745.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_site')));
  746.         }
  747.  
  748.         // If the component admin directory does not exist, let's create it
  749.         $created = false;
  750.  
  751.         if (!file_exists($this->parent->getPath('extension_administrator')))
  752.         {
  753.             if (!$created = JFolder::create($this->parent->getPath('extension_administrator')))
  754.             {
  755.                 JLog::add(
  756.                     JText::sprintf('JLIB_INSTALLER_ERROR_COMP_UPDATE_FAILED_TO_CREATE_DIRECTORY_ADMIN', $this->parent->getPath('extension_administrator')),
  757.                     JLog::WARNING, 'jerror'
  758.                 );
  759.  
  760.                 // Install failed, rollback any changes
  761.                 $this->parent->abort();
  762.  
  763.                 return false;
  764.             }
  765.         }
  766.  
  767.         /*
  768.          * Since we created the component admin directory and we will want to remove it if we have to roll
  769.          * back the installation, let's add it to the installation step stack
  770.          */
  771.         if ($created)
  772.         {
  773.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_administrator')));
  774.         }
  775.  
  776.         // Find files to copy
  777.         if ($this->manifest->files)
  778.         {
  779.             if ($this->parent->parseFiles($this->manifest->files, 0, $this->oldFiles) === false)
  780.             {
  781.                 // Install failed, rollback any changes
  782.                 $this->parent->abort();
  783.  
  784.                 return false;
  785.             }
  786.         }
  787.  
  788.         if ($this->manifest->administration->files)
  789.         {
  790.             if ($this->parent->parseFiles($this->manifest->administration->files, 1, $this->oldAdminFiles) === false)
  791.             {
  792.                 // Install failed, rollback any changes
  793.                 $this->parent->abort();
  794.  
  795.                 return false;
  796.             }
  797.         }
  798.  
  799.         // Parse optional tags
  800.         $this->parent->parseMedia($this->manifest->media);
  801.         $this->parent->parseLanguages($this->manifest->languages);
  802.         $this->parent->parseLanguages($this->manifest->administration->languages, 1);
  803.  
  804.         // If there is a manifest script, let's copy it.
  805.         if ($this->get('manifest_script'))
  806.         {
  807.             $path['src'] = $this->parent->getPath('source') . '/' . $this->get('manifest_script');
  808.             $path['dest'] = $this->parent->getPath('extension_administrator') . '/' . $this->get('manifest_script');
  809.  
  810.             if (!file_exists($path['dest']) || $this->parent->isOverwrite())
  811.             {
  812.                 if (!$this->parent->copyFiles(array($path)))
  813.                 {
  814.                     // Install failed, rollback changes
  815.                     $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_UPDATE_MANIFEST'));
  816.  
  817.                     return false;
  818.                 }
  819.             }
  820.         }
  821.  
  822.         /**
  823.          * ---------------------------------------------------------------------------------------------
  824.          * Database Processing Section
  825.          * ---------------------------------------------------------------------------------------------
  826.          */
  827.  
  828.         // Let's run the update queries for the component
  829.         $row = JTable::getInstance('extension');
  830.         $eid = $row->find(array('element' => strtolower($this->get('element')), 'type' => 'component'));
  831.  
  832.         if ($this->manifest->update)
  833.         {
  834.             $result = $this->parent->parseSchemaUpdates($this->manifest->update->schemas, $eid);
  835.  
  836.             if ($result === false)
  837.             {
  838.                 // Install failed, rollback changes
  839.                 $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_UPDATE_SQL_ERROR', $db->stderr(true)));
  840.  
  841.                 return false;
  842.             }
  843.         }
  844.  
  845.         // Time to build the admin menus
  846.         if (!$this->_buildAdminMenus($eid))
  847.         {
  848.             JLog::add(JText::_('JLIB_INSTALLER_ABORT_COMP_BUILDADMINMENUS_FAILED'), JLog::WARNING, 'jerror');
  849.  
  850.             // $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_ROLLBACK', $db->stderr(true)));
  851.             // Return false;
  852.         }
  853.  
  854.         /**
  855.          * ---------------------------------------------------------------------------------------------
  856.          * Custom Installation Script Section
  857.          * ---------------------------------------------------------------------------------------------
  858.          */
  859.  
  860.         /*
  861.          * If we have an install script, let's include it, execute the custom
  862.          * update method, and append the return value from the custom update
  863.          * method to the installation message.
  864.          */
  865.         ob_start();
  866.         ob_implicit_flush(false);
  867.  
  868.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'update'))
  869.         {
  870.             if ($this->parent->manifestClass->update($this) === false)
  871.             {
  872.                 // Install failed, rollback changes
  873.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  874.  
  875.                 return false;
  876.             }
  877.         }
  878.  
  879.         // Append messages
  880.         $msg .= ob_get_contents();
  881.         ob_end_clean();
  882.  
  883.         /**
  884.          * ---------------------------------------------------------------------------------------------
  885.          * Finalization and Cleanup Section
  886.          * ---------------------------------------------------------------------------------------------
  887.          */
  888.  
  889.         // Clobber any possible pending updates
  890.         $update = JTable::getInstance('update');
  891.         $uid = $update->find(array('element' => $this->get('element'), 'type' => 'component', 'client_id' => 1, 'folder' => ''));
  892.  
  893.         if ($uid)
  894.         {
  895.             $update->delete($uid);
  896.         }
  897.  
  898.         // Update an entry to the extension table
  899.         if ($eid)
  900.         {
  901.             $row->load($eid);
  902.         }
  903.         else
  904.         {
  905.             // Set the defaults
  906.             // There is no folder for components
  907.             $row->folder = '';
  908.             $row->enabled = 1;
  909.             $row->protected = 0;
  910.             $row->access = 1;
  911.             $row->client_id = 1;
  912.             $row->params = $this->parent->getParams();
  913.         }
  914.  
  915.         $row->name = $this->get('name');
  916.         $row->type = 'component';
  917.         $row->element = $this->get('element');
  918.         $row->manifest_cache = $this->parent->generateManifestCache();
  919.  
  920.         if (!$row->store())
  921.         {
  922.             // Install failed, roll back changes
  923.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_UPDATE_ROLLBACK', $db->stderr(true)));
  924.  
  925.             return false;
  926.         }
  927.  
  928.         // We will copy the manifest file to its appropriate place.
  929.         if (!$this->parent->copyManifest())
  930.         {
  931.             // Install failed, rollback changes
  932.             $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_UPDATE_COPY_SETUP'));
  933.  
  934.             return false;
  935.         }
  936.  
  937.         // And now we run the postflight
  938.         ob_start();
  939.         ob_implicit_flush(false);
  940.  
  941.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'postflight'))
  942.         {
  943.             $this->parent->manifestClass->postflight('update', $this);
  944.         }
  945.  
  946.         // Append messages
  947.         $msg .= ob_get_contents();
  948.         ob_end_clean();
  949.  
  950.         if ($msg != '')
  951.         {
  952.             $this->parent->set('extension_message', $msg);
  953.         }
  954.  
  955.         return $row->extension_id;
  956.     }
  957.  
  958.     /**
  959.      * Custom uninstall method for components
  960.      *
  961.      * @param   integer  $id  The unique extension id of the component to uninstall
  962.      *
  963.      * @return  mixed  Return value for uninstall method in component uninstall file
  964.      *
  965.      * @since   3.1
  966.      */
  967.     public function uninstall($id)
  968.     {
  969.         $db = $this->parent->getDbo();
  970.         $row = null;
  971.         $retval = true;
  972.  
  973.         // First order of business will be to load the component object table from the database.
  974.         // This should give us the necessary information to proceed.
  975.         $row = JTable::getInstance('extension');
  976.  
  977.         if (!$row->load((int) $id))
  978.         {
  979.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_ERRORUNKOWNEXTENSION'), JLog::WARNING, 'jerror');
  980.  
  981.             return false;
  982.         }
  983.  
  984.         // Is the component we are trying to uninstall a core one?
  985.         // Because that is not a good idea...
  986.         if ($row->protected)
  987.         {
  988.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_WARNCORECOMPONENT'), JLog::WARNING, 'jerror');
  989.  
  990.             return false;
  991.         }
  992.  
  993.         // Get the admin and site paths for the component
  994.         $this->parent->setPath('extension_administrator', JPath::clean(JPATH_ADMINISTRATOR . '/components/' . $row->element));
  995.         $this->parent->setPath('extension_site', JPath::clean(JPATH_SITE . '/components/' . $row->element));
  996.  
  997.         // Copy the admin path as it's used as a common base
  998.         $this->parent->setPath('extension_root', $this->parent->getPath('extension_administrator'));
  999.  
  1000.         /**
  1001.          * ---------------------------------------------------------------------------------------------
  1002.          * Manifest Document Setup Section
  1003.          * ---------------------------------------------------------------------------------------------
  1004.          */
  1005.  
  1006.         // Find and load the XML install file for the component
  1007.         $this->parent->setPath('source', $this->parent->getPath('extension_administrator'));
  1008.  
  1009.         // Get the package manifest object
  1010.         // We do findManifest to avoid problem when uninstalling a list of extension: getManifest cache its manifest file
  1011.         $this->parent->findManifest();
  1012.         $this->manifest = $this->parent->getManifest();
  1013.  
  1014.         if (!$this->manifest)
  1015.         {
  1016.             // Make sure we delete the folders if no manifest exists
  1017.             JFolder::delete($this->parent->getPath('extension_administrator'));
  1018.             JFolder::delete($this->parent->getPath('extension_site'));
  1019.  
  1020.             // Remove the menu
  1021.             $this->_removeAdminMenus($row);
  1022.  
  1023.             // Raise a warning
  1024.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_ERRORREMOVEMANUALLY'), JLog::WARNING, 'jerror');
  1025.  
  1026.             // Return
  1027.             return false;
  1028.         }
  1029.  
  1030.         // Set the extensions name
  1031.         $name = strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  1032.  
  1033.         if (substr($name, 0, 4) == 'com_')
  1034.         {
  1035.             $element = $name;
  1036.         }
  1037.         else
  1038.         {
  1039.             $element = 'com_' . $name;
  1040.         }
  1041.  
  1042.         $this->set('name', $name);
  1043.         $this->set('element', $element);
  1044.  
  1045.         // Attempt to load the admin language file; might have uninstall strings
  1046.         $this->loadLanguage(JPATH_ADMINISTRATOR . '/components/' . $element);
  1047.  
  1048.         /**
  1049.          * ---------------------------------------------------------------------------------------------
  1050.          * Installer Trigger Loading and Uninstall
  1051.          * ---------------------------------------------------------------------------------------------
  1052.          */
  1053.  
  1054.         // If there is an manifest class file, lets load it; we'll copy it later (don't have dest yet)
  1055.         $scriptFile = (string) $this->manifest->scriptfile;
  1056.  
  1057.         if ($scriptFile)
  1058.         {
  1059.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $scriptFile;
  1060.  
  1061.             if (is_file($manifestScriptFile))
  1062.             {
  1063.                 // Load the file
  1064.                 include_once $manifestScriptFile;
  1065.             }
  1066.  
  1067.             // Set the class name
  1068.             $classname = $row->element . 'InstallerScript';
  1069.  
  1070.             if (class_exists($classname))
  1071.             {
  1072.                 // Create a new instance
  1073.                 $this->parent->manifestClass = new $classname($this);
  1074.  
  1075.                 // And set this so we can copy it later
  1076.                 $this->set('manifest_script', $scriptFile);
  1077.             }
  1078.         }
  1079.  
  1080.         ob_start();
  1081.         ob_implicit_flush(false);
  1082.  
  1083.         // Run uninstall if possible
  1084.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'uninstall'))
  1085.         {
  1086.             $this->parent->manifestClass->uninstall($this);
  1087.         }
  1088.  
  1089.         $msg = ob_get_contents();
  1090.         ob_end_clean();
  1091.  
  1092.         if ($msg != '')
  1093.         {
  1094.             $this->parent->set('extension_message', $msg);
  1095.         }
  1096.  
  1097.         /**
  1098.          * ---------------------------------------------------------------------------------------------
  1099.          * Database Processing Section
  1100.          * ---------------------------------------------------------------------------------------------
  1101.          */
  1102.  
  1103.         // Let's run the uninstall queries for the component
  1104.         if (isset($this->manifest->uninstall->sql))
  1105.         {
  1106.             $result = $this->parent->parseSQLFiles($this->manifest->uninstall->sql);
  1107.  
  1108.             if ($result === false)
  1109.             {
  1110.                 // Install failed, rollback changes
  1111.                 JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_SQL_ERROR', $db->stderr(true)), JLog::WARNING, 'jerror');
  1112.                 $retval = false;
  1113.             }
  1114.         }
  1115.  
  1116.         $this->_removeAdminMenus($row);
  1117.  
  1118.         /**
  1119.          * ---------------------------------------------------------------------------------------------
  1120.          * Filesystem Processing Section
  1121.          * ---------------------------------------------------------------------------------------------
  1122.          */
  1123.  
  1124.         // Let's remove those language files and media in the JROOT/images/ folder that are
  1125.         // associated with the component we are uninstalling
  1126.         $this->parent->removeFiles($this->manifest->media);
  1127.         $this->parent->removeFiles($this->manifest->languages);
  1128.         $this->parent->removeFiles($this->manifest->administration->languages, 1);
  1129.  
  1130.         // Remove the schema version
  1131.         $query = $db->getQuery(true)
  1132.             ->delete('#__schemas')
  1133.             ->where('extension_id = ' . $id);
  1134.         $db->setQuery($query);
  1135.         $db->execute();
  1136.  
  1137.         // Remove the component container in the assets table.
  1138.         $asset = JTable::getInstance('Asset');
  1139.  
  1140.         if ($asset->loadByName($element))
  1141.         {
  1142.             $asset->delete();
  1143.         }
  1144.  
  1145.         // Remove categories for this component
  1146.         $query->clear()
  1147.             ->delete('#__categories')
  1148.             ->where('extension=' . $db->quote($element), 'OR')
  1149.             ->where('extension LIKE ' . $db->quote($element . '.%'));
  1150.         $db->setQuery($query);
  1151.         $db->execute();
  1152.  
  1153.         // Clobber any possible pending updates
  1154.         $update = JTable::getInstance('update');
  1155.         $uid = $update->find(array('element' => $row->element, 'type' => 'component', 'client_id' => 1, 'folder' => ''));
  1156.  
  1157.         if ($uid)
  1158.         {
  1159.             $update->delete($uid);
  1160.         }
  1161.  
  1162.         // Now we need to delete the installation directories. This is the final step in uninstalling the component.
  1163.         if (trim($row->element))
  1164.         {
  1165.             // Delete the component site directory
  1166.             if (is_dir($this->parent->getPath('extension_site')))
  1167.             {
  1168.                 if (!JFolder::delete($this->parent->getPath('extension_site')))
  1169.                 {
  1170.                     JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_FAILED_REMOVE_DIRECTORY_SITE'), JLog::WARNING, 'jerror');
  1171.                     $retval = false;
  1172.                 }
  1173.             }
  1174.  
  1175.             // Delete the component admin directory
  1176.             if (is_dir($this->parent->getPath('extension_administrator')))
  1177.             {
  1178.                 if (!JFolder::delete($this->parent->getPath('extension_administrator')))
  1179.                 {
  1180.                     JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_FAILED_REMOVE_DIRECTORY_ADMIN'), JLog::WARNING, 'jerror');
  1181.                     $retval = false;
  1182.                 }
  1183.             }
  1184.  
  1185.             // Now we will no longer need the extension object, so let's delete it and free up memory
  1186.             $row->delete($row->extension_id);
  1187.             unset($row);
  1188.  
  1189.             return $retval;
  1190.         }
  1191.         else
  1192.         {
  1193.             // No component option defined... cannot delete what we don't know about
  1194.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_UNINSTALL_NO_OPTION'), JLog::WARNING, 'jerror');
  1195.  
  1196.             return false;
  1197.         }
  1198.     }
  1199.  
  1200.     /**
  1201.      * Method to build menu database entries for a component
  1202.      *
  1203.      * @return  boolean  True if successful
  1204.      *
  1205.      * @since   3.1
  1206.      */
  1207.     protected function _buildAdminMenus()
  1208.     {
  1209.         $db = $this->parent->getDbo();
  1210.         $table = JTable::getInstance('menu');
  1211.         $option = $this->get('element');
  1212.  
  1213.         // If a component exists with this option in the table then we don't need to add menus
  1214.         $query = $db->getQuery(true)
  1215.             ->select('m.id, e.extension_id')
  1216.             ->from('#__menu AS m')
  1217.             ->join('LEFT', '#__extensions AS e ON m.component_id = e.extension_id')
  1218.             ->where('m.parent_id = 1')
  1219.             ->where('m.client_id = 1')
  1220.             ->where('e.element = ' . $db->quote($option));
  1221.  
  1222.         $db->setQuery($query);
  1223.  
  1224.         $componentrow = $db->loadObject();
  1225.  
  1226.         // Check if menu items exist
  1227.         if ($componentrow)
  1228.         {
  1229.             // Don't do anything if overwrite has not been enabled
  1230.             if (!$this->parent->isOverwrite())
  1231.             {
  1232.                 return true;
  1233.             }
  1234.  
  1235.             // Remove existing menu items if overwrite has been enabled
  1236.             if ($option)
  1237.             {
  1238.                 // If something goes wrong, there's no way to rollback TODO: Search for better solution
  1239.                 $this->_removeAdminMenus($componentrow);
  1240.             }
  1241.  
  1242.             $component_id = $componentrow->extension_id;
  1243.         }
  1244.         else
  1245.         {
  1246.             // Lets find the extension id
  1247.             $query->clear()
  1248.                 ->select('e.extension_id')
  1249.                 ->from('#__extensions AS e')
  1250.                 ->where('e.element = ' . $db->quote($option));
  1251.  
  1252.             $db->setQuery($query);
  1253.  
  1254.             // TODO Find Some better way to discover the component_id
  1255.             $component_id = $db->loadResult();
  1256.         }
  1257.  
  1258.         // Ok, now its time to handle the menus.  Start with the component root menu, then handle submenus.
  1259.         $menuElement = $this->manifest->administration->menu;
  1260.  
  1261.         if ($menuElement)
  1262.         {
  1263.             $data = array();
  1264.             $data['menutype'] = 'main';
  1265.             $data['client_id'] = 1;
  1266.             $data['title'] = (string) trim($menuElement);
  1267.             $data['alias'] = (string) $menuElement;
  1268.             $data['link'] = 'index.php?option=' . $option;
  1269.             $data['type'] = 'component';
  1270.             $data['published'] = 0;
  1271.             $data['parent_id'] = 1;
  1272.             $data['component_id'] = $component_id;
  1273.             $data['img'] = ((string) $menuElement->attributes()->img) ? (string) $menuElement->attributes()->img : 'class:component';
  1274.             $data['home'] = 0;
  1275.  
  1276.             try
  1277.             {
  1278.                 $table->setLocation(1, 'last-child');
  1279.             }
  1280.             catch (InvalidArgumentException $e)
  1281.             {
  1282.                 JLog::add($e->getMessage(), JLog::WARNING, 'jerror');
  1283.  
  1284.                 return false;
  1285.             }
  1286.  
  1287.             if (!$table->bind($data) || !$table->check() || !$table->store())
  1288.             {
  1289.                 // The menu item already exists. Delete it and retry instead of throwing an error.
  1290.                 $query->clear()
  1291.                     ->select('id')
  1292.                     ->from('#__menu')
  1293.                     ->where('menutype = ' . $db->quote('main'))
  1294.                     ->where('client_id = 1')
  1295.                     ->where('link = ' . $db->quote('index.php?option=' . $option))
  1296.                     ->where('type = ' . $db->quote('component'))
  1297.                     ->where('parent_id = 1')
  1298.                     ->where('home = 0');
  1299.  
  1300.                 $db->setQuery($query);
  1301.                 $menu_id = $db->loadResult();
  1302.  
  1303.                 if (!$menu_id)
  1304.                 {
  1305.                     // Oops! Could not get the menu ID. Go back and rollback changes.
  1306.                     JError::raiseWarning(1, $table->getError());
  1307.  
  1308.                     return false;
  1309.                 }
  1310.                 else
  1311.                 {
  1312.                     // Remove the old menu item
  1313.                     $query->clear()
  1314.                         ->delete('#__menu')
  1315.                         ->where('id = ' . (int) $menu_id);
  1316.  
  1317.                     $db->setQuery($query);
  1318.                     $db->query();
  1319.  
  1320.                     // Retry creating the menu item
  1321.                     $table->setLocation(1, 'last-child');
  1322.  
  1323.                     if (!$table->bind($data) || !$table->check() || !$table->store())
  1324.                     {
  1325.                         // Install failed, warn user and rollback changes
  1326.                         JError::raiseWarning(1, $table->getError());
  1327.  
  1328.                         return false;
  1329.                     }
  1330.                 }
  1331.             }
  1332.  
  1333.             /*
  1334.              * Since we have created a menu item, we add it to the installation step stack
  1335.              * so that if we have to rollback the changes we can undo it.
  1336.              */
  1337.             $this->parent->pushStep(array('type' => 'menu', 'id' => $component_id));
  1338.         }
  1339.         // No menu element was specified, Let's make a generic menu item
  1340.         else
  1341.         {
  1342.             $data = array();
  1343.             $data['menutype'] = 'main';
  1344.             $data['client_id'] = 1;
  1345.             $data['title'] = $option;
  1346.             $data['alias'] = $option;
  1347.             $data['link'] = 'index.php?option=' . $option;
  1348.             $data['type'] = 'component';
  1349.             $data['published'] = 0;
  1350.             $data['parent_id'] = 1;
  1351.             $data['component_id'] = $component_id;
  1352.             $data['img'] = 'class:component';
  1353.             $data['home'] = 0;
  1354.  
  1355.             try
  1356.             {
  1357.                 $table->setLocation(1, 'last-child');
  1358.             }
  1359.             catch (InvalidArgumentException $e)
  1360.             {
  1361.                 JLog::add($e->getMessage(), JLog::WARNING, 'jerror');
  1362.  
  1363.                 return false;
  1364.             }
  1365.  
  1366.             if (!$table->bind($data) || !$table->check() || !$table->store())
  1367.             {
  1368.                 // Install failed, warn user and rollback changes
  1369.                 JLog::add($table->getError(), JLog::WARNING, 'jerror');
  1370.  
  1371.                 return false;
  1372.             }
  1373.  
  1374.             /*
  1375.              * Since we have created a menu item, we add it to the installation step stack
  1376.              * so that if we have to rollback the changes we can undo it.
  1377.              */
  1378.             $this->parent->pushStep(array('type' => 'menu', 'id' => $component_id));
  1379.         }
  1380.  
  1381.         /*
  1382.          * Process SubMenus
  1383.          */
  1384.  
  1385.         if (!$this->manifest->administration->submenu)
  1386.         {
  1387.             return true;
  1388.         }
  1389.  
  1390.         $parent_id = $table->id;
  1391.  
  1392.         foreach ($this->manifest->administration->submenu->menu as $child)
  1393.         {
  1394.             $data = array();
  1395.             $data['menutype'] = 'main';
  1396.             $data['client_id'] = 1;
  1397.             $data['title'] = (string) trim($child);
  1398.             $data['alias'] = (string) $child;
  1399.             $data['type'] = 'component';
  1400.             $data['published'] = 0;
  1401.             $data['parent_id'] = $parent_id;
  1402.             $data['component_id'] = $component_id;
  1403.             $data['img'] = ((string) $child->attributes()->img) ? (string) $child->attributes()->img : 'class:component';
  1404.             $data['home'] = 0;
  1405.  
  1406.             // Set the sub menu link
  1407.             if ((string) $child->attributes()->link)
  1408.             {
  1409.                 $data['link'] = 'index.php?' . $child->attributes()->link;
  1410.             }
  1411.             else
  1412.             {
  1413.                 $request = array();
  1414.  
  1415.                 if ((string) $child->attributes()->act)
  1416.                 {
  1417.                     $request[] = 'act=' . $child->attributes()->act;
  1418.                 }
  1419.  
  1420.                 if ((string) $child->attributes()->task)
  1421.                 {
  1422.                     $request[] = 'task=' . $child->attributes()->task;
  1423.                 }
  1424.  
  1425.                 if ((string) $child->attributes()->controller)
  1426.                 {
  1427.                     $request[] = 'controller=' . $child->attributes()->controller;
  1428.                 }
  1429.  
  1430.                 if ((string) $child->attributes()->view)
  1431.                 {
  1432.                     $request[] = 'view=' . $child->attributes()->view;
  1433.                 }
  1434.  
  1435.                 if ((string) $child->attributes()->layout)
  1436.                 {
  1437.                     $request[] = 'layout=' . $child->attributes()->layout;
  1438.                 }
  1439.  
  1440.                 if ((string) $child->attributes()->sub)
  1441.                 {
  1442.                     $request[] = 'sub=' . $child->attributes()->sub;
  1443.                 }
  1444.  
  1445.                 $qstring = (count($request)) ? '&' . implode('&', $request) : '';
  1446.                 $data['link'] = 'index.php?option=' . $option . $qstring;
  1447.             }
  1448.  
  1449.             $table = JTable::getInstance('menu');
  1450.  
  1451.             try
  1452.             {
  1453.                 $table->setLocation($parent_id, 'last-child');
  1454.             }
  1455.             catch (InvalidArgumentException $e)
  1456.             {
  1457.                 return false;
  1458.             }
  1459.  
  1460.             if (!$table->bind($data) || !$table->check() || !$table->store())
  1461.             {
  1462.                 // Install failed, rollback changes
  1463.                 return false;
  1464.             }
  1465.  
  1466.             /*
  1467.              * Since we have created a menu item, we add it to the installation step stack
  1468.              * so that if we have to rollback the changes we can undo it.
  1469.              */
  1470.             $this->parent->pushStep(array('type' => 'menu', 'id' => $component_id));
  1471.         }
  1472.  
  1473.         return true;
  1474.     }
  1475.  
  1476.     /**
  1477.      * Method to remove admin menu references to a component
  1478.      *
  1479.      * @param   object  &$row  Component table object.
  1480.      *
  1481.      * @return  boolean  True if successful.
  1482.      *
  1483.      * @since   3.1
  1484.      */
  1485.     protected function _removeAdminMenus(&$row)
  1486.     {
  1487.         $db = $this->parent->getDbo();
  1488.         $table = JTable::getInstance('menu');
  1489.         $id = $row->extension_id;
  1490.  
  1491.         // Get the ids of the menu items
  1492.         $query = $db->getQuery(true)
  1493.             ->select('id')
  1494.             ->from('#__menu')
  1495.             ->where($db->quoteName('client_id') . ' = 1')
  1496.             ->where($db->quoteName('component_id') . ' = ' . (int) $id);
  1497.  
  1498.         $db->setQuery($query);
  1499.  
  1500.         $ids = $db->loadColumn();
  1501.  
  1502.         // Check for error
  1503.         if (!empty($ids))
  1504.         {
  1505.             // Iterate the items to delete each one.
  1506.             foreach ($ids as $menuid)
  1507.             {
  1508.                 if (!$table->delete((int) $menuid))
  1509.                 {
  1510.                     $this->setError($table->getError());
  1511.  
  1512.                     return false;
  1513.                 }
  1514.             }
  1515.             // Rebuild the whole tree
  1516.             $table->rebuild();
  1517.  
  1518.         }
  1519.         return true;
  1520.     }
  1521.  
  1522.     /**
  1523.      * Custom rollback method
  1524.      * - Roll back the component menu item
  1525.      *
  1526.      * @param   array  $step  Installation step to rollback.
  1527.      *
  1528.      * @return  boolean  True on success
  1529.      *
  1530.      * @since   3.1
  1531.      */
  1532.     protected function _rollback_menu($step)
  1533.     {
  1534.         return $this->_removeAdminMenus((object) array('extension_id' => $step['id']));
  1535.     }
  1536.  
  1537.     /**
  1538.      * Discover unregistered extensions.
  1539.      *
  1540.      * @return  array  A list of extensions.
  1541.      *
  1542.      * @since   3.1
  1543.      */
  1544.     public function discover()
  1545.     {
  1546.         $results = array();
  1547.         $site_components = JFolder::folders(JPATH_SITE . '/components');
  1548.         $admin_components = JFolder::folders(JPATH_ADMINISTRATOR . '/components');
  1549.  
  1550.         foreach ($site_components as $component)
  1551.         {
  1552.             if (file_exists(JPATH_SITE . '/components/' . $component . '/' . str_replace('com_', '', $component) . '.xml'))
  1553.             {
  1554.                 $manifest_details = JInstaller::parseXMLInstallFile(
  1555.                     JPATH_SITE . '/components/' . $component . '/' . str_replace('com_', '', $component) . '.xml'
  1556.                 );
  1557.                 $extension = JTable::getInstance('extension');
  1558.                 $extension->set('type', 'component');
  1559.                 $extension->set('client_id', 0);
  1560.                 $extension->set('element', $component);
  1561.                 $extension->set('folder', '');
  1562.                 $extension->set('name', $component);
  1563.                 $extension->set('state', -1);
  1564.                 $extension->set('manifest_cache', json_encode($manifest_details));
  1565.                 $extension->set('params', '{}');
  1566.                 $results[] = $extension;
  1567.             }
  1568.         }
  1569.  
  1570.         foreach ($admin_components as $component)
  1571.         {
  1572.             if (file_exists(JPATH_ADMINISTRATOR . '/components/' . $component . '/' . str_replace('com_', '', $component) . '.xml'))
  1573.             {
  1574.                 $manifest_details = JInstaller::parseXMLInstallFile(
  1575.                     JPATH_ADMINISTRATOR . '/components/' . $component . '/' . str_replace('com_', '', $component) . '.xml'
  1576.                 );
  1577.                 $extension = JTable::getInstance('extension');
  1578.                 $extension->set('type', 'component');
  1579.                 $extension->set('client_id', 1);
  1580.                 $extension->set('element', $component);
  1581.                 $extension->set('folder', '');
  1582.                 $extension->set('name', $component);
  1583.                 $extension->set('state', -1);
  1584.                 $extension->set('manifest_cache', json_encode($manifest_details));
  1585.                 $extension->set('params', '{}');
  1586.                 $results[] = $extension;
  1587.             }
  1588.         }
  1589.         return $results;
  1590.     }
  1591.  
  1592.     /**
  1593.      * Install unregistered extensions that have been discovered.
  1594.      *
  1595.      * @return  mixed 
  1596.      *
  1597.      * @since   3.1
  1598.      */
  1599.     public function discover_install()
  1600.     {
  1601.         // Need to find to find where the XML file is since we don't store this normally
  1602.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  1603.         $short_element = str_replace('com_', '', $this->parent->extension->element);
  1604.         $manifestPath = $client->path . '/components/' . $this->parent->extension->element . '/' . $short_element . '.xml';
  1605.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  1606.         $this->parent->setPath('manifest', $manifestPath);
  1607.         $this->parent->setPath('source', $client->path . '/components/' . $this->parent->extension->element);
  1608.         $this->parent->setPath('extension_root', $this->parent->getPath('source'));
  1609.  
  1610.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  1611.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  1612.         $this->parent->extension->state = 0;
  1613.         $this->parent->extension->name = $manifest_details['name'];
  1614.         $this->parent->extension->enabled = 1;
  1615.         $this->parent->extension->params = $this->parent->getParams();
  1616.  
  1617.         try
  1618.         {
  1619.             $this->parent->extension->store();
  1620.         }
  1621.         catch (RuntimeException $e)
  1622.         {
  1623.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_DISCOVER_STORE_DETAILS'), JLog::WARNING, 'jerror');
  1624.  
  1625.             return false;
  1626.         }
  1627.  
  1628.         // Now we need to run any SQL it has, languages, media or menu stuff
  1629.  
  1630.         // Get a database connector object
  1631.         $db = $this->parent->getDbo();
  1632.  
  1633.         // Get the extension manifest object
  1634.         $this->manifest = $this->parent->getManifest();
  1635.  
  1636.         /**
  1637.          * ---------------------------------------------------------------------------------------------
  1638.          * Manifest Document Setup Section
  1639.          * ---------------------------------------------------------------------------------------------
  1640.          */
  1641.  
  1642.         // Set the extensions name
  1643.         $name = strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  1644.  
  1645.         if (substr($name, 0, 4) == 'com_')
  1646.         {
  1647.             $element = $name;
  1648.         }
  1649.         else
  1650.         {
  1651.             $element = 'com_' . $name;
  1652.         }
  1653.  
  1654.         $this->set('name', $name);
  1655.         $this->set('element', $element);
  1656.  
  1657.         // Get the component description
  1658.         $description = (string) $this->manifest->description;
  1659.  
  1660.         if ($description)
  1661.         {
  1662.             $this->parent->set('message', JText::_((string) $description));
  1663.         }
  1664.         else
  1665.         {
  1666.             $this->parent->set('message', '');
  1667.         }
  1668.  
  1669.         // Set the installation target paths
  1670.         $this->parent->setPath('extension_site', JPath::clean(JPATH_SITE . '/components/' . $this->get('element')));
  1671.         $this->parent->setPath('extension_administrator', JPath::clean(JPATH_ADMINISTRATOR . '/components/' . $this->get('element')));
  1672.  
  1673.         // Copy the admin path as it's used as a common base
  1674.         $this->parent->setPath('extension_root', $this->parent->getPath('extension_administrator'));
  1675.  
  1676.         /**
  1677.          * ---------------------------------------------------------------------------------------------
  1678.          * Basic Checks Section
  1679.          * ---------------------------------------------------------------------------------------------
  1680.          */
  1681.  
  1682.         // Make sure that we have an admin element
  1683.         if (!$this->manifest->administration)
  1684.         {
  1685.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_INSTALL_ADMIN_ELEMENT'), JLog::WARNING, 'jerror');
  1686.  
  1687.             return false;
  1688.         }
  1689.  
  1690.         /**
  1691.          * ---------------------------------------------------------------------------------------------
  1692.          * Installer Trigger Loading
  1693.          * ---------------------------------------------------------------------------------------------
  1694.          */
  1695.         // If there is an manifest class file, lets load it; we'll copy it later (don't have dest yet)
  1696.         $manifestScript = (string) $this->manifest->scriptfile;
  1697.  
  1698.         if ($manifestScript)
  1699.         {
  1700.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  1701.  
  1702.             if (is_file($manifestScriptFile))
  1703.             {
  1704.                 // Load the file
  1705.                 include_once $manifestScriptFile;
  1706.             }
  1707.  
  1708.             // Set the class name
  1709.             $classname = $element . 'InstallerScript';
  1710.  
  1711.             if (class_exists($classname))
  1712.             {
  1713.                 // Create a new instance
  1714.                 $this->parent->manifestClass = new $classname($this);
  1715.  
  1716.                 // And set this so we can copy it later
  1717.                 $this->set('manifest_script', $manifestScript);
  1718.             }
  1719.         }
  1720.  
  1721.         // Run preflight if possible (since we know we're not an update)
  1722.         ob_start();
  1723.         ob_implicit_flush(false);
  1724.  
  1725.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  1726.         {
  1727.  
  1728.             if ($this->parent->manifestClass->preflight('discover_install', $this) === false)
  1729.             {
  1730.                 // Install failed, rollback changes
  1731.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  1732.  
  1733.                 return false;
  1734.             }
  1735.         }
  1736.  
  1737.         // Create msg object; first use here
  1738.         $msg = ob_get_contents();
  1739.         ob_end_clean();
  1740.  
  1741.         /*
  1742.          *
  1743.          * Normally we would copy files and create directories, lets skip to the optional files
  1744.          * Note: need to dereference things!
  1745.          * Parse optional tags
  1746.          * @todo remove code: $this->parent->parseMedia($this->manifest->media);
  1747.          *
  1748.          * We don't do language because 1.6 suggests moving to extension based languages
  1749.          * @todo remove code: $this->parent->parseLanguages($this->manifest->languages);
  1750.          * @todo remove code: $this->parent->parseLanguages($this->manifest->administration->languages, 1);
  1751.          */
  1752.  
  1753.         /**
  1754.          * ---------------------------------------------------------------------------------------------
  1755.          * Database Processing Section
  1756.          * ---------------------------------------------------------------------------------------------
  1757.          */
  1758.  
  1759.         // Let's run the install queries for the component
  1760.         if (isset($this->manifest->install->sql))
  1761.         {
  1762.             $utfresult = $this->parent->parseSQLFiles($this->manifest->install->sql);
  1763.  
  1764.             if ($utfresult === false)
  1765.             {
  1766.                 // Install failed, rollback changes
  1767.                 $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_SQL_ERROR', $db->stderr(true)));
  1768.  
  1769.                 return false;
  1770.             }
  1771.         }
  1772.  
  1773.         // Time to build the admin menus
  1774.         if (!$this->_buildAdminMenus($this->parent->extension->extension_id))
  1775.         {
  1776.             JLog::add(JText::_('JLIB_INSTALLER_ABORT_COMP_BUILDADMINMENUS_FAILED'), JLog::WARNING, 'jerror');
  1777.  
  1778.             // @todo remove code: $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_COMP_INSTALL_ROLLBACK', $db->stderr(true)));
  1779.  
  1780.             // @todo remove code: return false;
  1781.         }
  1782.  
  1783.         /**
  1784.          * ---------------------------------------------------------------------------------------------
  1785.          * Custom Installation Script Section
  1786.          * ---------------------------------------------------------------------------------------------
  1787.          */
  1788.  
  1789.         /*
  1790.          * If we have an install script, lets include it, execute the custom
  1791.          * discover_install method, and append the return value from the custom discover_install
  1792.          * method to the installation message.
  1793.          */
  1794.         ob_start();
  1795.         ob_implicit_flush(false);
  1796.  
  1797.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'install'))
  1798.         {
  1799.  
  1800.             if ($this->parent->manifestClass->install($this) === false)
  1801.             {
  1802.                 // Install failed, rollback changes
  1803.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_COMP_INSTALL_CUSTOM_INSTALL_FAILURE'));
  1804.  
  1805.                 return false;
  1806.             }
  1807.         }
  1808.  
  1809.         // Append messages
  1810.         $msg .= ob_get_contents();
  1811.         ob_end_clean();
  1812.  
  1813.         /**
  1814.          * ---------------------------------------------------------------------------------------------
  1815.          * Finalization and Cleanup Section
  1816.          * ---------------------------------------------------------------------------------------------
  1817.          */
  1818.  
  1819.         // Clobber any possible pending updates
  1820.         $update = JTable::getInstance('update');
  1821.         $uid = $update->find(array('element' => $this->get('element'), 'type' => 'component', 'client_id' => 1, 'folder' => ''));
  1822.  
  1823.         if ($uid)
  1824.         {
  1825.             $update->delete($uid);
  1826.         }
  1827.  
  1828.         // And now we run the postflight
  1829.         ob_start();
  1830.         ob_implicit_flush(false);
  1831.  
  1832.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'postflight'))
  1833.         {
  1834.             $this->parent->manifestClass->postflight('discover_install', $this);
  1835.         }
  1836.  
  1837.         // Append messages
  1838.         $msg .= ob_get_contents();
  1839.         ob_end_clean();
  1840.  
  1841.         if ($msg != '')
  1842.         {
  1843.             $this->parent->set('extension_message', $msg);
  1844.         }
  1845.  
  1846.         return $this->parent->extension->extension_id;
  1847.     }
  1848.  
  1849.     /**
  1850.      * Refreshes the extension table cache
  1851.      *
  1852.      * @return  boolean  Result of operation, true if updated, false on failure
  1853.      *
  1854.      * @since   3.1
  1855.      */
  1856.     public function refreshManifestCache()
  1857.     {
  1858.         // Need to find to find where the XML file is since we don't store this normally
  1859.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  1860.         $short_element = str_replace('com_', '', $this->parent->extension->element);
  1861.         $manifestPath = $client->path . '/components/' . $this->parent->extension->element . '/' . $short_element . '.xml';
  1862.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  1863.         $this->parent->setPath('manifest', $manifestPath);
  1864.  
  1865.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  1866.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  1867.         $this->parent->extension->name = $manifest_details['name'];
  1868.  
  1869.         try
  1870.         {
  1871.             return $this->parent->extension->store();
  1872.         }
  1873.         catch (RuntimeException $e)
  1874.         {
  1875.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_COMP_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
  1876.  
  1877.             return false;
  1878.         }
  1879.     }
  1880. }
  1881.  
  1882. /**
  1883.  * Deprecated class placeholder. You should use JInstallerAdapterComponent instead.
  1884.  *
  1885.  * @package     Joomla.Libraries
  1886.  * @subpackage  Installer
  1887.  * @since       3.1
  1888.  * @deprecated  4.0
  1889.  * @codeCoverageIgnore
  1890.  */
  1891. class JInstallerComponent extends JInstallerAdapterComponent
  1892. {
  1893. }

Documentation generated on Tue, 19 Nov 2013 14:56:23 +0100 by phpDocumentor 1.4.3