Source for file plugin.php

Documentation is available at plugin.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_plugins
  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.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. /**
  13.  * Plugin model.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_plugins
  17.  * @since       1.6
  18.  */
  19. class PluginsModelPlugin extends JModelAdmin
  20. {
  21.     /**
  22.      * @var        string    The help screen key for the module.
  23.      * @since   1.6
  24.      */
  25.     protected $helpKey = 'JHELP_EXTENSIONS_PLUGIN_MANAGER_EDIT';
  26.  
  27.     /**
  28.      * @var        string    The help screen base URL for the module.
  29.      * @since   1.6
  30.      */
  31.     protected $helpURL;
  32.  
  33.     protected $_cache;
  34.  
  35.     /**
  36.      * @var        string    The event to trigger after saving the data.
  37.      * @since   1.6
  38.      */
  39.     protected $event_after_save = 'onExtensionAfterSave';
  40.  
  41.     /**
  42.      * @var        string    The event to trigger after before the data.
  43.      * @since   1.6
  44.      */
  45.     protected $event_before_save = 'onExtensionBeforeSave';
  46.  
  47.     /**
  48.      * Method to get the record form.
  49.      *
  50.      * @param   array  $data        Data for the form.
  51.      * @param   boolean    $loadData    True if the form is to load its own data (default case), false if not.
  52.      * @return  JForm    A JForm object on success, false on failure
  53.      * @since   1.6
  54.      */
  55.     public function getForm($data = array(), $loadData = true)
  56.     {
  57.         // The folder and element vars are passed when saving the form.
  58.         if (empty($data))
  59.         {
  60.             $item        = $this->getItem();
  61.             $folder        = $item->folder;
  62.             $element    = $item->element;
  63.         }
  64.         else
  65.         {
  66.             $folder        = JArrayHelper::getValue($data, 'folder', '', 'cmd');
  67.             $element    = JArrayHelper::getValue($data, 'element', '', 'cmd');
  68.         }
  69.  
  70.         // These variables are used to add data from the plugin XML files.
  71.         $this->setState('item.folder',    $folder);
  72.         $this->setState('item.element',    $element);
  73.  
  74.         // Get the form.
  75.         $form = $this->loadForm('com_plugins.plugin', 'plugin', array('control' => 'jform', 'load_data' => $loadData));
  76.         if (empty($form))
  77.         {
  78.             return false;
  79.         }
  80.  
  81.         // Modify the form based on access controls.
  82.         if (!$this->canEditState((object) $data))
  83.         {
  84.             // Disable fields for display.
  85.             $form->setFieldAttribute('ordering', 'disabled', 'true');
  86.             $form->setFieldAttribute('enabled', 'disabled', 'true');
  87.  
  88.             // Disable fields while saving.
  89.             // The controller has already verified this is a record you can edit.
  90.             $form->setFieldAttribute('ordering', 'filter', 'unset');
  91.             $form->setFieldAttribute('enabled', 'filter', 'unset');
  92.         }
  93.  
  94.         return $form;
  95.     }
  96.  
  97.     /**
  98.      * Method to get the data that should be injected in the form.
  99.      *
  100.      * @return  mixed  The data for the form.
  101.      * @since   1.6
  102.      */
  103.     protected function loadFormData()
  104.     {
  105.         // Check the session for previously entered form data.
  106.         $data = JFactory::getApplication()->getUserState('com_plugins.edit.plugin.data', array());
  107.  
  108.         if (empty($data))
  109.         {
  110.             $data = $this->getItem();
  111.         }
  112.  
  113.         $this->preprocessData('com_plugins.plugin', $data);
  114.  
  115.         return $data;
  116.     }
  117.  
  118.     /**
  119.      * Method to get a single record.
  120.      *
  121.      * @param   integer    The id of the primary key.
  122.      *
  123.      * @return  mixed  Object on success, false on failure.
  124.      */
  125.     public function getItem($pk = null)
  126.     {
  127.         $pk = (!empty($pk)) ? $pk : (int) $this->getState('plugin.id');
  128.  
  129.         if (!isset($this->_cache[$pk]))
  130.         {
  131.             $false    = false;
  132.  
  133.             // Get a row instance.
  134.             $table = $this->getTable();
  135.  
  136.             // Attempt to load the row.
  137.             $return = $table->load($pk);
  138.  
  139.             // Check for a table object error.
  140.             if ($return === false && $table->getError())
  141.             {
  142.                 $this->setError($table->getError());
  143.                 return $false;
  144.             }
  145.  
  146.             // Convert to the JObject before adding other data.
  147.             $properties = $table->getProperties(1);
  148.             $this->_cache[$pk] = JArrayHelper::toObject($properties, 'JObject');
  149.  
  150.             // Convert the params field to an array.
  151.             $registry = new JRegistry;
  152.             $registry->loadString($table->params);
  153.             $this->_cache[$pk]->params = $registry->toArray();
  154.  
  155.             // Get the plugin XML.
  156.             $path = JPath::clean(JPATH_PLUGINS.'/'.$table->folder.'/'.$table->element.'/'.$table->element.'.xml');
  157.  
  158.             if (file_exists($path))
  159.             {
  160.                 $this->_cache[$pk]->xml = simplexml_load_file($path);
  161.             } else {
  162.                 $this->_cache[$pk]->xml = null;
  163.             }
  164.         }
  165.  
  166.         return $this->_cache[$pk];
  167.     }
  168.  
  169.     /**
  170.      * Returns a reference to the a Table object, always creating it.
  171.      *
  172.      * @param   type    The table type to instantiate
  173.      * @param   string    A prefix for the table class name. Optional.
  174.      * @param   array  Configuration array for model. Optional.
  175.      * @return  JTable    A database object
  176.     */
  177.     public function getTable($type = 'Extension', $prefix = 'JTable', $config = array())
  178.     {
  179.         return JTable::getInstance($type, $prefix, $config);
  180.     }
  181.  
  182.     /**
  183.      * Auto-populate the model state.
  184.      *
  185.      * Note. Calling getState in this method will result in recursion.
  186.      *
  187.      * @return  void 
  188.      * @since   1.6
  189.      */
  190.     protected function populateState()
  191.     {
  192.         // Execute the parent method.
  193.         parent::populateState();
  194.  
  195.         $app = JFactory::getApplication('administrator');
  196.  
  197.         // Load the User state.
  198.         $pk = $app->input->getInt('extension_id');
  199.         $this->setState('plugin.id', $pk);
  200.     }
  201.  
  202.     /**
  203.      * @param   object    A form object.
  204.      * @param   mixed    The data expected for the form.
  205.      * @return  mixed  True if successful.
  206.      * @throws    Exception if there is an error in the form event.
  207.      * @since   1.6
  208.      */
  209.     protected function preprocessForm(JForm $form, $data, $group = 'content')
  210.     {
  211.         jimport('joomla.filesystem.path');
  212.  
  213.         $folder        = $this->getState('item.folder');
  214.         $element    = $this->getState('item.element');
  215.         $lang        = JFactory::getLanguage();
  216.  
  217.         // Load the core and/or local language sys file(s) for the ordering field.
  218.         $db = JFactory::getDbo();
  219.         $query = 'SELECT element' .
  220.                 ' FROM #__extensions' .
  221.                 ' WHERE (type =' .$db->quote('plugin'). 'AND folder='. $db->quote($folder) . ')';
  222.         $db->setQuery($query);
  223.         $elements = $db->loadColumn();
  224.  
  225.         foreach ($elements as $elementa)
  226.         {
  227.                 $lang->load('plg_'.$folder.'_'.$elementa.'.sys', JPATH_ADMINISTRATOR, null, false, true)
  228.             ||    $lang->load('plg_'.$folder.'_'.$elementa.'.sys', JPATH_PLUGINS.'/'.$folder.'/'.$elementa, null, false, true);
  229.         }
  230.  
  231.         if (empty($folder) || empty($element))
  232.         {
  233.             $app = JFactory::getApplication();
  234.             $app->redirect(JRoute::_('index.php?option=com_plugins&view=plugins', false));
  235.         }
  236.  
  237.         $formFile = JPath::clean(JPATH_PLUGINS . '/' . $folder . '/' . $element . '/' . $element . '.xml');
  238.         if (!file_exists($formFile))
  239.         {
  240.             throw new Exception(JText::sprintf('COM_PLUGINS_ERROR_FILE_NOT_FOUND', $element . '.xml'));
  241.         }
  242.  
  243.         // Load the core and/or local language file(s).
  244.             $lang->load('plg_'.$folder.'_'.$element, JPATH_ADMINISTRATOR, null, false, true)
  245.         ||    $lang->load('plg_'.$folder.'_'.$element, JPATH_PLUGINS.'/'.$folder.'/'.$element, null, false, true);
  246.  
  247.         if (file_exists($formFile))
  248.         {
  249.             // Get the plugin form.
  250.             if (!$form->loadFile($formFile, false, '//config'))
  251.             {
  252.                 throw new Exception(JText::_('JERROR_LOADFILE_FAILED'));
  253.             }
  254.         }
  255.  
  256.         // Attempt to load the xml file.
  257.         if (!$xml = simplexml_load_file($formFile))
  258.         {
  259.             throw new Exception(JText::_('JERROR_LOADFILE_FAILED'));
  260.         }
  261.  
  262.         // Get the help data from the XML file if present.
  263.         $help = $xml->xpath('/extension/help');
  264.         if (!empty($help))
  265.         {
  266.             $helpKey = trim((string) $help[0]['key']);
  267.             $helpURL = trim((string) $help[0]['url']);
  268.  
  269.             $this->helpKey = $helpKey ? $helpKey : $this->helpKey;
  270.             $this->helpURL = $helpURL ? $helpURL : $this->helpURL;
  271.         }
  272.  
  273.         // Trigger the default form events.
  274.         parent::preprocessForm($form, $data, $group);
  275.     }
  276.  
  277.     /**
  278.      * A protected method to get a set of ordering conditions.
  279.      *
  280.      * @param   object    A record object.
  281.      * @return  array  An array of conditions to add to add to ordering queries.
  282.      * @since   1.6
  283.      */
  284.     protected function getReorderConditions($table)
  285.     {
  286.         $condition = array();
  287.         $condition[] = 'type = '. $this->_db->quote($table->type);
  288.         $condition[] = 'folder = '. $this->_db->quote($table->folder);
  289.         return $condition;
  290.     }
  291.  
  292.     /**
  293.      * Override method to save the form data.
  294.      *
  295.      * @param   array  The form data.
  296.      * @return  boolean  True on success.
  297.      * @since   1.6
  298.      */
  299.     public function save($data)
  300.     {
  301.         // Load the extension plugin group.
  302.         JPluginHelper::importPlugin('extension');
  303.  
  304.         // Setup type
  305.         $data['type'] = 'plugin';
  306.  
  307.         return parent::save($data);
  308.     }
  309.  
  310.     /**
  311.      * Get the necessary data to load an item help screen.
  312.      *
  313.      * @return  object  An object with key, url, and local properties for loading the item help screen.
  314.      * @since   1.6
  315.      */
  316.     public function getHelp()
  317.     {
  318.         return (object) array('key' => $this->helpKey, 'url' => $this->helpURL);
  319.     }
  320.  
  321.     /**
  322.      * Custom clean cache method, plugins are cached in 2 places for different clients
  323.      *
  324.      * @since   1.6
  325.      */
  326.     protected function cleanCache($group = null, $client_id = 0)
  327.     {
  328.         parent::cleanCache('com_plugins');
  329.     }
  330. }

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