Source for file module.php

Documentation is available at module.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.  * Module installer
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Installer
  20.  * @since       3.1
  21.  */
  22. class JInstallerAdapterModule 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.      * Extension name
  51.      *
  52.      * @var    string 
  53.      * @since  3.1
  54.      */
  55.     protected $name = null;
  56.  
  57.     /**
  58.      * Extension element
  59.      *
  60.      * @var    string 
  61.      * @since  3.1
  62.      */
  63.     protected $element = null;
  64.  
  65.     /**
  66.      * <scriptfile> element of the extension manifest
  67.      *
  68.      * @var    object 
  69.      * @since  3.1
  70.      */
  71.     protected $scriptElement = null;
  72.  
  73.     /**
  74.      * Custom loadLanguage method
  75.      *
  76.      * @param   string  $path  The path where we 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
  89.                 ->setPath(
  90.                 'source',
  91.                 ($this->parent->extension->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) . '/modules/' . $this->parent->extension->element
  92.             );
  93.         }
  94.  
  95.         $this->manifest = $this->parent->getManifest();
  96.  
  97.         if ($this->manifest->files)
  98.         {
  99.             $element = $this->manifest->files;
  100.             $extension = '';
  101.  
  102.             if (count($element->children()))
  103.             {
  104.                 foreach ($element->children() as $file)
  105.                 {
  106.                     if ((string) $file->attributes()->module)
  107.                     {
  108.                         $extension = strtolower((string) $file->attributes()->module);
  109.                         break;
  110.                     }
  111.                 }
  112.             }
  113.  
  114.             if ($extension)
  115.             {
  116.                 $lang = JFactory::getLanguage();
  117.                 $source = $path ? $path : ($this->parent->extension->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) . '/modules/' . $extension;
  118.                 $folder = (string) $element->attributes()->folder;
  119.  
  120.                 if ($folder && file_exists($path . '/' . $folder))
  121.                 {
  122.                     $source = $path . '/' . $folder;
  123.                 }
  124.  
  125.                 $client = (string) $this->manifest->attributes()->client;
  126.                 $lang->load($extension . '.sys', $source, null, false, true)
  127.                     || $lang->load($extension . '.sys', constant('JPATH_' . strtoupper($client)), null, false, true);
  128.             }
  129.         }
  130.     }
  131.  
  132.     /**
  133.      * Custom install method
  134.      *
  135.      * @return  boolean  True on success
  136.      *
  137.      * @since   3.1
  138.      */
  139.     public function install()
  140.     {
  141.         // Get a database connector object
  142.         $db = $this->parent->getDbo();
  143.  
  144.         // Get the extension manifest object
  145.         $this->manifest = $this->parent->getManifest();
  146.  
  147.         /*
  148.          * ---------------------------------------------------------------------------------------------
  149.          * Manifest Document Setup Section
  150.          * ---------------------------------------------------------------------------------------------
  151.          */
  152.  
  153.         // Set the extensions name
  154.         $name = (string) $this->manifest->name;
  155.         $name = JFilterInput::getInstance()->clean($name, 'string');
  156.         $this->set('name', $name);
  157.  
  158.         // Get the module description
  159.         $description = (string) $this->manifest->description;
  160.  
  161.         if ($description)
  162.         {
  163.             $this->parent->set('message', JText::_($description));
  164.         }
  165.         else
  166.         {
  167.             $this->parent->set('message', '');
  168.         }
  169.  
  170.         /*
  171.          * ---------------------------------------------------------------------------------------------
  172.          * Target Application Section
  173.          * ---------------------------------------------------------------------------------------------
  174.          */
  175.  
  176.         // Get the target application
  177.         if ($cname = (string) $this->manifest->attributes()->client)
  178.         {
  179.             // Attempt to map the client to a base path
  180.             $client = JApplicationHelper::getClientInfo($cname, true);
  181.  
  182.             if ($client === false)
  183.             {
  184.                 $this->parent
  185.                     ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_UNKNOWN_CLIENT', JText::_('JLIB_INSTALLER_' . $this->route), $client->name));
  186.  
  187.                 return false;
  188.             }
  189.  
  190.             $basePath = $client->path;
  191.             $clientId = $client->id;
  192.         }
  193.         else
  194.         {
  195.             // No client attribute was found so we assume the site as the client
  196.             $basePath = JPATH_SITE;
  197.             $clientId = 0;
  198.         }
  199.  
  200.         // Set the installation path
  201.         $element = '';
  202.  
  203.         if (count($this->manifest->files->children()))
  204.         {
  205.             foreach ($this->manifest->files->children() as $file)
  206.             {
  207.                 if ((string) $file->attributes()->module)
  208.                 {
  209.                     $element = (string) $file->attributes()->module;
  210.                     $this->set('element', $element);
  211.  
  212.                     break;
  213.                 }
  214.             }
  215.         }
  216.         if (!empty($element))
  217.         {
  218.             $this->parent->setPath('extension_root', $basePath . '/modules/' . $element);
  219.         }
  220.         else
  221.         {
  222.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_INSTALL_NOFILE', JText::_('JLIB_INSTALLER_' . $this->route)));
  223.  
  224.             return false;
  225.         }
  226.  
  227.         /*
  228.          * Check to see if a module by the same name is already installed
  229.          * If it is, then update the table because if the files aren't there
  230.          * we can assume that it was (badly) uninstalled
  231.          * If it isn't, add an entry to extensions
  232.          */
  233.         $query = $db->getQuery(true)
  234.             ->select($db->quoteName('extension_id'))
  235.             ->from($db->quoteName('#__extensions'))
  236.             ->where($db->quoteName('element') . ' = ' . $db->quote($element))
  237.             ->where($db->quoteName('client_id') . ' = ' . (int) $clientId);
  238.         $db->setQuery($query);
  239.  
  240.         try
  241.         {
  242.             $db->execute();
  243.         }
  244.         catch (RuntimeException $e)
  245.         {
  246.             // Install failed, roll back changes
  247.             $this->parent
  248.                 ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_ROLLBACK', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true)));
  249.  
  250.             return false;
  251.         }
  252.  
  253.         $id = $db->loadResult();
  254.  
  255.         /*
  256.          * If the module directory already exists, then we will assume that the
  257.          * module is already installed or another module is using that
  258.          * directory.
  259.          * Check that this is either an issue where its not overwriting or it is
  260.          * set to upgrade anyway
  261.          */
  262.  
  263.         if (file_exists($this->parent->getPath('extension_root')) && (!$this->parent->isOverwrite() || $this->parent->isUpgrade()))
  264.         {
  265.             // Look for an update function or update tag
  266.             $updateElement = $this->manifest->update;
  267.  
  268.             // Upgrade manually set or update function available or update tag detected
  269.             if ($this->parent->isUpgrade() || ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'update'))
  270.                 || $updateElement)
  271.             {
  272.                 // Force this one
  273.                 $this->parent->setOverwrite(true);
  274.                 $this->parent->setUpgrade(true);
  275.  
  276.                 if ($id)
  277.                 {
  278.                     // If there is a matching extension mark this as an update; semantics really
  279.                     $this->route = 'Update';
  280.                 }
  281.             }
  282.             elseif (!$this->parent->isOverwrite())
  283.             {
  284.                 // Overwrite is set
  285.                 // We didn't have overwrite set, find an update function or find an update tag so lets call it safe
  286.                 $this->parent
  287.                     ->abort(
  288.                     JText::sprintf(
  289.                         'JLIB_INSTALLER_ABORT_MOD_INSTALL_DIRECTORY', JText::_('JLIB_INSTALLER_' . $this->route),
  290.                         $this->parent->getPath('extension_root')
  291.                     )
  292.                 );
  293.  
  294.                 return false;
  295.             }
  296.         }
  297.  
  298.         /*
  299.          * ---------------------------------------------------------------------------------------------
  300.          * Installer Trigger Loading
  301.          * ---------------------------------------------------------------------------------------------
  302.          */
  303.  
  304.         // If there is an manifest class file, let's load it; we'll copy it later (don't have destination yet)
  305.         $this->scriptElement = $this->manifest->scriptfile;
  306.         $manifestScript = (string) $this->manifest->scriptfile;
  307.  
  308.         if ($manifestScript)
  309.         {
  310.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  311.  
  312.             if (is_file($manifestScriptFile))
  313.             {
  314.                 // Load the file
  315.                 include_once $manifestScriptFile;
  316.             }
  317.  
  318.             // Set the class name
  319.             $classname = $element . 'InstallerScript';
  320.  
  321.             if (class_exists($classname))
  322.             {
  323.                 // Create a new instance.
  324.                 $this->parent->manifestClass = new $classname($this);
  325.  
  326.                 // And set this so we can copy it later.
  327.                 $this->set('manifest_script', $manifestScript);
  328.             }
  329.         }
  330.  
  331.         // Run preflight if possible (since we know we're not an update)
  332.         ob_start();
  333.         ob_implicit_flush(false);
  334.  
  335.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  336.         {
  337.             if ($this->parent->manifestClass->preflight($this->route, $this) === false)
  338.             {
  339.                 // Preflight failed, rollback changes
  340.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_MOD_INSTALL_CUSTOM_INSTALL_FAILURE'));
  341.  
  342.                 return false;
  343.             }
  344.         }
  345.  
  346.         // Create msg object; first use here
  347.         $msg = ob_get_contents();
  348.         ob_end_clean();
  349.  
  350.         /*
  351.          * ---------------------------------------------------------------------------------------------
  352.          * Filesystem Processing Section
  353.          * ---------------------------------------------------------------------------------------------
  354.          */
  355.  
  356.         // If the module directory does not exist, lets create it
  357.         $created = false;
  358.  
  359.         if (!file_exists($this->parent->getPath('extension_root')))
  360.         {
  361.             if (!$created = JFolder::create($this->parent->getPath('extension_root')))
  362.             {
  363.                 $this->parent
  364.                     ->abort(
  365.                     JText::sprintf(
  366.                         'JLIB_INSTALLER_ABORT_MOD_INSTALL_CREATE_DIRECTORY', JText::_('JLIB_INSTALLER_' . $this->route),
  367.                         $this->parent->getPath('extension_root')
  368.                     )
  369.                 );
  370.  
  371.                 return false;
  372.             }
  373.         }
  374.  
  375.         /*
  376.          * Since we created the module directory and will want to remove it if
  377.          * we have to roll back the installation, let's add it to the
  378.          * installation step stack
  379.          */
  380.  
  381.         if ($created)
  382.         {
  383.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_root')));
  384.         }
  385.  
  386.         // Copy all necessary files
  387.         if ($this->parent->parseFiles($this->manifest->files, -1) === false)
  388.         {
  389.             // Install failed, roll back changes
  390.             $this->parent->abort();
  391.  
  392.             return false;
  393.         }
  394.  
  395.         // If there is a manifest script, let's copy it.
  396.         if ($this->get('manifest_script'))
  397.         {
  398.             $path['src'] = $this->parent->getPath('source') . '/' . $this->get('manifest_script');
  399.             $path['dest'] = $this->parent->getPath('extension_root') . '/' . $this->get('manifest_script');
  400.  
  401.             if (!file_exists($path['dest']) || $this->parent->isOverwrite())
  402.             {
  403.                 if (!$this->parent->copyFiles(array($path)))
  404.                 {
  405.                     // Install failed, rollback changes
  406.                     $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_MOD_INSTALL_MANIFEST'));
  407.  
  408.                     return false;
  409.                 }
  410.             }
  411.         }
  412.  
  413.         // Parse optional tags
  414.         $this->parent->parseMedia($this->manifest->media, $clientId);
  415.         $this->parent->parseLanguages($this->manifest->languages, $clientId);
  416.  
  417.         /*
  418.          * ---------------------------------------------------------------------------------------------
  419.          * Database Processing Section
  420.          * ---------------------------------------------------------------------------------------------
  421.          */
  422.  
  423.         $row = JTable::getInstance('extension');
  424.  
  425.         // Was there a module already installed with the same name?
  426.         if ($id)
  427.         {
  428.             // Load the entry and update the manifest_cache
  429.             $row->load($id);
  430.  
  431.             // Update name
  432.             $row->name = $this->get('name');
  433.  
  434.             // Update manifest
  435.             $row->manifest_cache = $this->parent->generateManifestCache();
  436.  
  437.             if (!$row->store())
  438.             {
  439.                 // Install failed, roll back changes
  440.                 $this->parent
  441.                     ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_ROLLBACK', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true)));
  442.  
  443.                 return false;
  444.             }
  445.         }
  446.         else
  447.         {
  448.             $row->set('name', $this->get('name'));
  449.             $row->set('type', 'module');
  450.             $row->set('element', $this->get('element'));
  451.  
  452.             // There is no folder for modules
  453.             $row->set('folder', '');
  454.             $row->set('enabled', 1);
  455.             $row->set('protected', 0);
  456.             $row->set('access', $clientId == 1 ? 2 : 0);
  457.             $row->set('client_id', $clientId);
  458.             $row->set('params', $this->parent->getParams());
  459.  
  460.             // Custom data
  461.             $row->set('custom_data', '');
  462.             $row->set('manifest_cache', $this->parent->generateManifestCache());
  463.  
  464.             if (!$row->store())
  465.             {
  466.                 // Install failed, roll back changes
  467.                 $this->parent
  468.                     ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_ROLLBACK', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true)));
  469.  
  470.                 return false;
  471.             }
  472.  
  473.             // Since we have created a module item, we add it to the installation step stack
  474.             // so that if we have to rollback the changes we can undo it.
  475.             $this->parent->pushStep(array('type' => 'extension', 'extension_id' => $row->extension_id));
  476.  
  477.             // Create unpublished module in jos_modules
  478.             $name = preg_replace('#[\*?]#', '', JText::_($this->get('name')));
  479.             $module = JTable::getInstance('module');
  480.             $module->set('title', $name);
  481.             $module->set('content', '');
  482.             $module->set('module', $this->get('element'));
  483.             $module->set('access', '1');
  484.             $module->set('showtitle', '1');
  485.             $module->set('params', '');
  486.             $module->set('client_id', $clientId);
  487.             $module->set('language', '*');
  488.  
  489.             $module->store();
  490.         }
  491.  
  492.         // Let's run the queries for the module
  493.         if (strtolower($this->route) == 'install')
  494.         {
  495.             $result = $this->parent->parseSQLFiles($this->manifest->install->sql);
  496.  
  497.             if ($result === false)
  498.             {
  499.                 // Install failed, rollback changes
  500.                 $this->parent
  501.                     ->abort(
  502.                     JText::sprintf('JLIB_INSTALLER_ABORT_MOD_INSTALL_SQL_ERROR', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true))
  503.                 );
  504.  
  505.                 return false;
  506.             }
  507.  
  508.             // Set the schema version to be the latest update version
  509.             if ($this->manifest->update)
  510.             {
  511.                 $this->parent->setSchemaVersion($this->manifest->update->schemas, $row->extension_id);
  512.             }
  513.         }
  514.         elseif (strtolower($this->route) == 'update')
  515.         {
  516.             if ($this->manifest->update)
  517.             {
  518.                 $result = $this->parent->parseSchemaUpdates($this->manifest->update->schemas, $row->extension_id);
  519.  
  520.                 if ($result === false)
  521.                 {
  522.                     // Install failed, rollback changes
  523.                     $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_MOD_UPDATE_SQL_ERROR', $db->stderr(true)));
  524.  
  525.                     return false;
  526.                 }
  527.             }
  528.         }
  529.  
  530.         // Run the custom method based on the route
  531.         ob_start();
  532.         ob_implicit_flush(false);
  533.  
  534.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, $this->route))
  535.         {
  536.             if ($this->parent->manifestClass->{$this->route}($this) === false)
  537.             {
  538.                 // Install failed, rollback changes
  539.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_MOD_INSTALL_CUSTOM_INSTALL_FAILURE'));
  540.  
  541.                 return false;
  542.             }
  543.         }
  544.  
  545.         // Append messages
  546.         $msg .= ob_get_contents();
  547.         ob_end_clean();
  548.  
  549.         /**
  550.          * ---------------------------------------------------------------------------------------------
  551.          * Finalization and Cleanup Section
  552.          * ---------------------------------------------------------------------------------------------
  553.          */
  554.  
  555.         // Lastly, we will copy the manifest file to its appropriate place.
  556.         if (!$this->parent->copyManifest(-1))
  557.         {
  558.             // Install failed, rollback changes
  559.             $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_MOD_INSTALL_COPY_SETUP'));
  560.  
  561.             return false;
  562.         }
  563.  
  564.         // And now we run the postflight
  565.         ob_start();
  566.         ob_implicit_flush(false);
  567.  
  568.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'postflight'))
  569.         {
  570.             $this->parent->manifestClass->postflight($this->route, $this);
  571.         }
  572.  
  573.         // Append messages
  574.         $msg .= ob_get_contents();
  575.         ob_end_clean();
  576.  
  577.         if ($msg != '')
  578.         {
  579.             $this->parent->set('extension_message', $msg);
  580.         }
  581.  
  582.         return $row->get('extension_id');
  583.     }
  584.  
  585.     /**
  586.      * Custom update method
  587.      *
  588.      * This is really a shell for the install system
  589.      *
  590.      * @return  boolean  True on success.
  591.      *
  592.      * @since   3.1
  593.      */
  594.     public function update()
  595.     {
  596.         // Set the overwrite setting
  597.         $this->parent->setOverwrite(true);
  598.         $this->parent->setUpgrade(true);
  599.  
  600.         // Set the route for the install
  601.         $this->route = 'update';
  602.  
  603.         // Go to install which handles updates properly
  604.         return $this->install();
  605.     }
  606.  
  607.     /**
  608.      * Custom discover method
  609.      *
  610.      * @return  array  JExtension list of extensions available
  611.      *
  612.      * @since   3.1
  613.      */
  614.     public function discover()
  615.     {
  616.         $results = array();
  617.         $site_list = JFolder::folders(JPATH_SITE . '/modules');
  618.         $admin_list = JFolder::folders(JPATH_ADMINISTRATOR . '/modules');
  619.         $site_info = JApplicationHelper::getClientInfo('site', true);
  620.         $admin_info = JApplicationHelper::getClientInfo('administrator', true);
  621.  
  622.         foreach ($site_list as $module)
  623.         {
  624.             $manifest_details = JInstaller::parseXMLInstallFile(JPATH_SITE . "/modules/$module/$module.xml");
  625.             $extension = JTable::getInstance('extension');
  626.             $extension->set('type', 'module');
  627.             $extension->set('client_id', $site_info->id);
  628.             $extension->set('element', $module);
  629.             $extension->set('folder', '');
  630.             $extension->set('name', $module);
  631.             $extension->set('state', -1);
  632.             $extension->set('manifest_cache', json_encode($manifest_details));
  633.             $extension->set('params', '{}');
  634.             $results[] = clone $extension;
  635.         }
  636.  
  637.         foreach ($admin_list as $module)
  638.         {
  639.             $manifest_details = JInstaller::parseXMLInstallFile(JPATH_ADMINISTRATOR . "/modules/$module/$module.xml");
  640.             $extension = JTable::getInstance('extension');
  641.             $extension->set('type', 'module');
  642.             $extension->set('client_id', $admin_info->id);
  643.             $extension->set('element', $module);
  644.             $extension->set('folder', '');
  645.             $extension->set('name', $module);
  646.             $extension->set('state', -1);
  647.             $extension->set('manifest_cache', json_encode($manifest_details));
  648.             $extension->set('params', '{}');
  649.             $results[] = clone $extension;
  650.         }
  651.  
  652.         return $results;
  653.     }
  654.  
  655.     /**
  656.      * Custom discover_install method
  657.      *
  658.      * @return  mixed  Extension ID on success, boolean false on failure
  659.      *
  660.      * @since   3.1
  661.      */
  662.     public function discover_install()
  663.     {
  664.         // Modules are like templates, and are one of the easiest
  665.         // If its not in the extensions table we just add it
  666.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  667.         $manifestPath = $client->path . '/modules/' . $this->parent->extension->element . '/' . $this->parent->extension->element . '.xml';
  668.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  669.         $description = (string) $this->parent->manifest->description;
  670.  
  671.         if ($description)
  672.         {
  673.             $this->parent->set('message', JText::_($description));
  674.         }
  675.         else
  676.         {
  677.             $this->parent->set('message', '');
  678.         }
  679.  
  680.         $this->parent->setPath('manifest', $manifestPath);
  681.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  682.  
  683.         // TODO: Re-evaluate this; should we run installation triggers? postflight perhaps?
  684.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  685.         $this->parent->extension->state = 0;
  686.         $this->parent->extension->name = $manifest_details['name'];
  687.         $this->parent->extension->enabled = 1;
  688.         $this->parent->extension->params = $this->parent->getParams();
  689.  
  690.         if ($this->parent->extension->store())
  691.         {
  692.             return $this->parent->extension->get('extension_id');
  693.         }
  694.         else
  695.         {
  696.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_MOD_DISCOVER_STORE_DETAILS'), JLog::WARNING, 'jerror');
  697.  
  698.             return false;
  699.         }
  700.     }
  701.  
  702.     /**
  703.      * Refreshes the extension table cache
  704.      *
  705.      * @return  boolean  Result of operation, true if updated, false on failure.
  706.      *
  707.      * @since   3.1
  708.      */
  709.     public function refreshManifestCache()
  710.     {
  711.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  712.         $manifestPath = $client->path . '/modules/' . $this->parent->extension->element . '/' . $this->parent->extension->element . '.xml';
  713.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  714.         $this->parent->setPath('manifest', $manifestPath);
  715.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  716.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  717.         $this->parent->extension->name = $manifest_details['name'];
  718.  
  719.         if ($this->parent->extension->store())
  720.         {
  721.             return true;
  722.         }
  723.         else
  724.         {
  725.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_MOD_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
  726.  
  727.             return false;
  728.         }
  729.     }
  730.  
  731.     /**
  732.      * Custom uninstall method
  733.      *
  734.      * @param   integer  $id  The id of the module to uninstall
  735.      *
  736.      * @return  boolean  True on success
  737.      *
  738.      * @since   3.1
  739.      */
  740.     public function uninstall($id)
  741.     {
  742.         $row = null;
  743.         $retval = true;
  744.         $db = $this->parent->getDbo();
  745.  
  746.         // First order of business will be to load the module object table from the database.
  747.         // This should give us the necessary information to proceed.
  748.         $row = JTable::getInstance('extension');
  749.  
  750.         if (!$row->load((int) $id) || !strlen($row->element))
  751.         {
  752.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_ERRORUNKOWNEXTENSION'), JLog::WARNING, 'jerror');
  753.  
  754.             return false;
  755.         }
  756.  
  757.         // Is the module we are trying to uninstall a core one?
  758.         // Because that is not a good idea...
  759.         if ($row->protected)
  760.         {
  761.             JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_WARNCOREMODULE', $row->name), JLog::WARNING, 'jerror');
  762.  
  763.             return false;
  764.         }
  765.  
  766.         // Get the extension root path
  767.         $element = $row->element;
  768.         $client = JApplicationHelper::getClientInfo($row->client_id);
  769.  
  770.         if ($client === false)
  771.         {
  772.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_UNKNOWN_CLIENT', $row->client_id));
  773.  
  774.             return false;
  775.         }
  776.         $this->parent->setPath('extension_root', $client->path . '/modules/' . $element);
  777.  
  778.         $this->parent->setPath('source', $this->parent->getPath('extension_root'));
  779.  
  780.         // Get the module's manifest objecct
  781.         // We do findManifest to avoid problem when uninstalling a list of extensions: getManifest cache its manifest file.
  782.         $this->parent->findManifest();
  783.         $this->manifest = $this->parent->getManifest();
  784.  
  785.         // Attempt to load the language file; might have uninstall strings
  786.         $this->loadLanguage(($row->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) . '/modules/' . $element);
  787.  
  788.         // If there is an manifest class file, let's load it
  789.         $this->scriptElement = $this->manifest->scriptfile;
  790.         $manifestScript = (string) $this->manifest->scriptfile;
  791.  
  792.         if ($manifestScript)
  793.         {
  794.             $manifestScriptFile = $this->parent->getPath('extension_root') . '/' . $manifestScript;
  795.  
  796.             if (is_file($manifestScriptFile))
  797.             {
  798.                 // Load the file
  799.                 include_once $manifestScriptFile;
  800.             }
  801.  
  802.             // Set the class name
  803.             $classname = $element . 'InstallerScript';
  804.  
  805.             if (class_exists($classname))
  806.             {
  807.                 // Create a new instance
  808.                 $this->parent->manifestClass = new $classname($this);
  809.  
  810.                 // And set this so we can copy it later
  811.                 $this->set('manifest_script', $manifestScript);
  812.             }
  813.         }
  814.  
  815.         ob_start();
  816.         ob_implicit_flush(false);
  817.  
  818.         // Run uninstall if possible
  819.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'uninstall'))
  820.         {
  821.             $this->parent->manifestClass->uninstall($this);
  822.         }
  823.  
  824.         $msg = ob_get_contents();
  825.         ob_end_clean();
  826.  
  827.         if ($msg != '')
  828.         {
  829.             $this->parent->set('extension_message', $msg);
  830.         }
  831.  
  832.         if (!($this->manifest instanceof SimpleXMLElement))
  833.         {
  834.             // Make sure we delete the folders
  835.             JFolder::delete($this->parent->getPath('extension_root'));
  836.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_INVALID_NOTFOUND_MANIFEST'), JLog::WARNING, 'jerror');
  837.  
  838.             return false;
  839.         }
  840.  
  841.         // Let's run the uninstall queries for the module
  842.         $result = $this->parent->parseSQLFiles($this->manifest->uninstall->sql);
  843.  
  844.         if ($result === false)
  845.         {
  846.             // Install failed, rollback changes
  847.             JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_SQL_ERROR', $db->stderr(true)), JLog::WARNING, 'jerror');
  848.             $retval = false;
  849.         }
  850.  
  851.         // Remove the schema version
  852.         $query = $db->getQuery(true)
  853.             ->delete('#__schemas')
  854.             ->where('extension_id = ' . $row->extension_id);
  855.         $db->setQuery($query);
  856.         $db->execute();
  857.  
  858.         // Remove other files
  859.         $this->parent->removeFiles($this->manifest->media);
  860.         $this->parent->removeFiles($this->manifest->languages, $row->client_id);
  861.  
  862.         // Let's delete all the module copies for the type we are uninstalling
  863.         $query->clear()
  864.             ->select($db->quoteName('id'))
  865.             ->from($db->quoteName('#__modules'))
  866.             ->where($db->quoteName('module') . ' = ' . $db->quote($row->element))
  867.             ->where($db->quoteName('client_id') . ' = ' . (int) $row->client_id);
  868.         $db->setQuery($query);
  869.  
  870.         try
  871.         {
  872.             $modules = $db->loadColumn();
  873.         }
  874.         catch (RuntimeException $e)
  875.         {
  876.             $modules = array();
  877.         }
  878.  
  879.         // Do we have any module copies?
  880.         if (count($modules))
  881.         {
  882.             // Ensure the list is sane
  883.             JArrayHelper::toInteger($modules);
  884.             $modID = implode(',', $modules);
  885.  
  886.             // Wipe out any items assigned to menus
  887.             $query = 'DELETE FROM #__modules_menu WHERE moduleid IN (' . $modID . ')';
  888.             $db->setQuery($query);
  889.  
  890.             try
  891.             {
  892.                 $db->execute();
  893.             }
  894.             catch (RuntimeException $e)
  895.             {
  896.                 JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_EXCEPTION', $db->stderr(true)), JLog::WARNING, 'jerror');
  897.                 $retval = false;
  898.             }
  899.  
  900.             // Wipe out any instances in the modules table
  901.             $query = 'DELETE FROM #__modules WHERE id IN (' . $modID . ')';
  902.             $db->setQuery($query);
  903.  
  904.             try
  905.             {
  906.                 $db->execute();
  907.             }
  908.             catch (RuntimeException $e)
  909.             {
  910.                 JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_MOD_UNINSTALL_EXCEPTION', $db->stderr(true)), JLog::WARNING, 'jerror');
  911.                 $retval = false;
  912.             }
  913.         }
  914.  
  915.         // Now we will no longer need the module object, so let's delete it and free up memory
  916.         $row->delete($row->extension_id);
  917.         $query = 'DELETE FROM #__modules WHERE module = ' . $db->quote($row->element) . ' AND client_id = ' . $row->client_id;
  918.         $db->setQuery($query);
  919.  
  920.         try
  921.         {
  922.             // Clean up any other ones that might exist as well
  923.             $db->execute();
  924.         }
  925.         catch (RuntimeException $e)
  926.         {
  927.             // Ignore the error...
  928.         }
  929.  
  930.         unset($row);
  931.  
  932.         // Remove the installation folder
  933.         if (!JFolder::delete($this->parent->getPath('extension_root')))
  934.         {
  935.             // JFolder should raise an error
  936.             $retval = false;
  937.         }
  938.  
  939.         return $retval;
  940.     }
  941.  
  942.     /**
  943.      * Custom rollback method
  944.      * - Roll back the menu item
  945.      *
  946.      * @param   array  $arg  Installation step to rollback
  947.      *
  948.      * @return  boolean  True on success
  949.      *
  950.      * @since   3.1
  951.      */
  952.     protected function _rollback_menu($arg)
  953.     {
  954.         // Get database connector object
  955.         $db = $this->parent->getDbo();
  956.  
  957.         // Remove the entry from the #__modules_menu table
  958.         $query = 'DELETE FROM #__modules_menu WHERE moduleid=' . (int) $arg['id'];
  959.         $db->setQuery($query);
  960.  
  961.         try
  962.         {
  963.             return $db->execute();
  964.         }
  965.         catch (RuntimeException $e)
  966.         {
  967.             return false;
  968.         }
  969.     }
  970.  
  971.     /**
  972.      * Custom rollback method
  973.      * - Roll back the module item
  974.      *
  975.      * @param   array  $arg  Installation step to rollback
  976.      *
  977.      * @return  boolean  True on success
  978.      *
  979.      * @since   3.1
  980.      */
  981.     protected function _rollback_module($arg)
  982.     {
  983.         // Get database connector object
  984.         $db = $this->parent->getDbo();
  985.  
  986.         // Remove the entry from the #__modules table
  987.         $query = 'DELETE FROM #__modules WHERE id=' . (int) $arg['id'];
  988.         $db->setQuery($query);
  989.  
  990.         try
  991.         {
  992.             return $db->execute();
  993.         }
  994.         catch (RuntimeException $e)
  995.         {
  996.             return false;
  997.         }
  998.     }
  999. }
  1000.  
  1001. /**
  1002.  * Deprecated class placeholder. You should use JInstallerAdapterModule instead.
  1003.  *
  1004.  * @package     Joomla.Libraries
  1005.  * @subpackage  Installer
  1006.  * @since       3.1
  1007.  * @deprecated  4.0
  1008.  * @codeCoverageIgnore
  1009.  */
  1010. class JInstallerModule extends JInstallerAdapterModule
  1011. {
  1012. }

Documentation generated on Tue, 19 Nov 2013 15:08:42 +0100 by phpDocumentor 1.4.3