Source for file style.php

Documentation is available at style.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_templates
  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.  * Template style model.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_templates
  17.  * @since       1.6
  18.  */
  19. class TemplatesModelStyle extends JModelAdmin
  20. {
  21.     /**
  22.      * @var        string    The help screen key for the module.
  23.      * @since   1.6
  24.      */
  25.     protected $helpKey = 'JHELP_EXTENSIONS_TEMPLATE_MANAGER_STYLES_EDIT';
  26.  
  27.     /**
  28.      * @var        string    The help screen base URL for the module.
  29.      * @since   1.6
  30.      */
  31.     protected $helpURL;
  32.  
  33.     /**
  34.      * Item cache.
  35.      */
  36.     private $_cache = array();
  37.  
  38.     /**
  39.      * Method to auto-populate the model state.
  40.      *
  41.      * Note. Calling getState in this method will result in recursion.
  42.      *
  43.      * @return  void 
  44.      *
  45.      * @since   1.6
  46.      */
  47.     protected function populateState()
  48.     {
  49.         $app = JFactory::getApplication('administrator');
  50.  
  51.         // Load the User state.
  52.         $pk = $app->input->getInt('id');
  53.         $this->setState('style.id', $pk);
  54.  
  55.         // Load the parameters.
  56.         $params    = JComponentHelper::getParams('com_templates');
  57.         $this->setState('params', $params);
  58.     }
  59.  
  60.     /**
  61.      * Method to delete rows.
  62.      *
  63.      * @param   array  &$pks  An array of item ids.
  64.      *
  65.      * @return  boolean  Returns true on success, false on failure.
  66.      */
  67.     public function delete(&$pks)
  68.     {
  69.         $pks    = (array) $pks;
  70.         $user    = JFactory::getUser();
  71.         $table    = $this->getTable();
  72.  
  73.         // Iterate the items to delete each one.
  74.         foreach ($pks as $pk)
  75.         {
  76.             if ($table->load($pk))
  77.             {
  78.                 // Access checks.
  79.                 if (!$user->authorise('core.delete', 'com_templates'))
  80.                 {
  81.                     throw new Exception(JText::_('JERROR_CORE_DELETE_NOT_PERMITTED'));
  82.                 }
  83.  
  84.                 // You should not delete a default style
  85.                 if ($table->home != '0')
  86.                 {
  87.                     JError::raiseWarning(SOME_ERROR_NUMBER, Jtext::_('COM_TEMPLATES_STYLE_CANNOT_DELETE_DEFAULT_STYLE'));
  88.  
  89.                     return false;
  90.                 }
  91.  
  92.                 if (!$table->delete($pk))
  93.                 {
  94.                     $this->setError($table->getError());
  95.  
  96.                     return false;
  97.                 }
  98.             }
  99.             else
  100.             {
  101.                 $this->setError($table->getError());
  102.  
  103.                 return false;
  104.             }
  105.         }
  106.  
  107.         // Clean cache
  108.         $this->cleanCache();
  109.  
  110.         return true;
  111.     }
  112.  
  113.     /**
  114.      * Method to duplicate styles.
  115.      *
  116.      * @param   array  &$pks  An array of primary key IDs.
  117.      *
  118.      * @return  boolean  True if successful.
  119.      *
  120.      * @throws    Exception
  121.      */
  122.     public function duplicate(&$pks)
  123.     {
  124.         $user    = JFactory::getUser();
  125.  
  126.         // Access checks.
  127.         if (!$user->authorise('core.create', 'com_templates'))
  128.         {
  129.             throw new Exception(JText::_('JERROR_CORE_CREATE_NOT_PERMITTED'));
  130.         }
  131.  
  132.         $table = $this->getTable();
  133.  
  134.         foreach ($pks as $pk)
  135.         {
  136.             if ($table->load($pk, true))
  137.             {
  138.                 // Reset the id to create a new record.
  139.                 $table->id = 0;
  140.  
  141.                 // Reset the home (don't want dupes of that field).
  142.                 $table->home = 0;
  143.  
  144.                 // Alter the title.
  145.                 $m = null;
  146.                 $table->title = $this->generateNewTitle(null, null, $table->title);
  147.  
  148.                 if (!$table->check() || !$table->store())
  149.                 {
  150.                     throw new Exception($table->getError());
  151.                 }
  152.             }
  153.             else
  154.             {
  155.                 throw new Exception($table->getError());
  156.             }
  157.         }
  158.  
  159.         // Clean cache
  160.         $this->cleanCache();
  161.  
  162.         return true;
  163.     }
  164.  
  165.     /**
  166.      * Method to change the title.
  167.      *
  168.      * @param   integer  $category_id  The id of the category.
  169.      * @param   string   $alias        The alias.
  170.      * @param   string   $title        The title.
  171.      *
  172.      * @return  string  New title.
  173.      *
  174.      * @since   1.7.1
  175.      */
  176.     protected function generateNewTitle($category_id, $alias, $title)
  177.     {
  178.         // Alter the title
  179.         $table = $this->getTable();
  180.  
  181.         while ($table->load(array('title' => $title)))
  182.         {
  183.             $title = JString::increment($title);
  184.         }
  185.  
  186.         return $title;
  187.     }
  188.  
  189.     /**
  190.      * Method to get the record form.
  191.      *
  192.      * @param   array    $data      An optional array of data for the form to interogate.
  193.      * @param   boolean  $loadData  True if the form is to load its own data (default case), false if not.
  194.      *
  195.      * @return  JForm  A JForm object on success, false on failure
  196.      *
  197.      * @since   1.6
  198.      */
  199.     public function getForm($data = array(), $loadData = true)
  200.     {
  201.         // The folder and element vars are passed when saving the form.
  202.         if (empty($data))
  203.         {
  204.             $item        = $this->getItem();
  205.             $clientId    = $item->client_id;
  206.             $template    = $item->template;
  207.         }
  208.         else
  209.         {
  210.             $clientId    = JArrayHelper::getValue($data, 'client_id');
  211.             $template    = JArrayHelper::getValue($data, 'template');
  212.         }
  213.  
  214.         // These variables are used to add data from the plugin XML files.
  215.         $this->setState('item.client_id',    $clientId);
  216.         $this->setState('item.template',    $template);
  217.  
  218.         // Get the form.
  219.         $form = $this->loadForm('com_templates.style', 'style', array('control' => 'jform', 'load_data' => $loadData));
  220.  
  221.         if (empty($form))
  222.         {
  223.             return false;
  224.         }
  225.  
  226.         // Modify the form based on access controls.
  227.         if (!$this->canEditState((object) $data))
  228.         {
  229.             // Disable fields for display.
  230.             $form->setFieldAttribute('home', 'disabled', 'true');
  231.  
  232.             // Disable fields while saving.
  233.             // The controller has already verified this is a record you can edit.
  234.             $form->setFieldAttribute('home', 'filter', 'unset');
  235.         }
  236.  
  237.         return $form;
  238.     }
  239.  
  240.     /**
  241.      * Method to get the data that should be injected in the form.
  242.      *
  243.      * @return  mixed  The data for the form.
  244.      *
  245.      * @since   1.6
  246.      */
  247.     protected function loadFormData()
  248.     {
  249.         // Check the session for previously entered form data.
  250.         $data = JFactory::getApplication()->getUserState('com_templates.edit.style.data', array());
  251.  
  252.         if (empty($data))
  253.         {
  254.             $data = $this->getItem();
  255.         }
  256.  
  257.         $this->preprocessData('com_templates.style', $data);
  258.  
  259.         return $data;
  260.     }
  261.  
  262.     /**
  263.      * Method to get a single record.
  264.      *
  265.      * @param   integer  $pk  The id of the primary key.
  266.      *
  267.      * @return  mixed  Object on success, false on failure.
  268.      */
  269.     public function getItem($pk = null)
  270.     {
  271.         $pk = (!empty($pk)) ? $pk : (int) $this->getState('style.id');
  272.  
  273.         if (!isset($this->_cache[$pk]))
  274.         {
  275.             $false    = false;
  276.  
  277.             // Get a row instance.
  278.             $table = $this->getTable();
  279.  
  280.             // Attempt to load the row.
  281.             $return = $table->load($pk);
  282.  
  283.             // Check for a table object error.
  284.             if ($return === false && $table->getError())
  285.             {
  286.                 $this->setError($table->getError());
  287.  
  288.                 return $false;
  289.             }
  290.  
  291.             // Convert to the JObject before adding other data.
  292.             $properties = $table->getProperties(1);
  293.             $this->_cache[$pk] = JArrayHelper::toObject($properties, 'JObject');
  294.  
  295.             // Convert the params field to an array.
  296.             $registry = new JRegistry;
  297.             $registry->loadString($table->params);
  298.             $this->_cache[$pk]->params = $registry->toArray();
  299.  
  300.             // Get the template XML.
  301.             $client    = JApplicationHelper::getClientInfo($table->client_id);
  302.             $path    = JPath::clean($client->path.'/templates/'.$table->template.'/templateDetails.xml');
  303.  
  304.             if (file_exists($path))
  305.             {
  306.                 $this->_cache[$pk]->xml = simplexml_load_file($path);
  307.             }
  308.             else
  309.             {
  310.                 $this->_cache[$pk]->xml = null;
  311.             }
  312.         }
  313.  
  314.         return $this->_cache[$pk];
  315.     }
  316.  
  317.     /**
  318.      * Returns a reference to the a Table object, always creating it.
  319.      *
  320.      * @param   type    $type    The table type to instantiate
  321.      * @param   string  $prefix  A prefix for the table class name. Optional.
  322.      * @param   array   $config  Configuration array for model. Optional.
  323.      *
  324.      * @return  JTable  A database object
  325.     */
  326.     public function getTable($type = 'Style', $prefix = 'TemplatesTable', $config = array())
  327.     {
  328.         return JTable::getInstance($type, $prefix, $config);
  329.     }
  330.  
  331.     /**
  332.      * TODO
  333.      *
  334.      * @param   object  $form   A form object.
  335.      * @param   mixed   $data   The data expected for the form.
  336.      * @param   string  $group  TODO
  337.      *
  338.      * @return  void 
  339.      *
  340.      * @since   1.6
  341.      * @throws    Exception if there is an error in the form event.
  342.      */
  343.     protected function preprocessForm(JForm $form, $data, $group = 'content')
  344.     {
  345.         $clientId = $this->getState('item.client_id');
  346.         $template = $this->getState('item.template');
  347.         $lang     = JFactory::getLanguage();
  348.         $client   = JApplicationHelper::getClientInfo($clientId);
  349.  
  350.         if (!$form->loadFile('style_'.$client->name, true))
  351.         {
  352.             throw new Exception(JText::_('JERROR_LOADFILE_FAILED'));
  353.         }
  354.  
  355.         jimport('joomla.filesystem.path');
  356.  
  357.         $formFile    = JPath::clean($client->path.'/templates/'.$template.'/templateDetails.xml');
  358.  
  359.         // Load the core and/or local language file(s).
  360.             $lang->load('tpl_'.$template, $client->path, null, false, true)
  361.         ||    $lang->load('tpl_'.$template, $client->path.'/templates/'.$template, null, false, true);
  362.  
  363.         if (file_exists($formFile))
  364.         {
  365.             // Get the template form.
  366.             if (!$form->loadFile($formFile, false, '//config'))
  367.             {
  368.                 throw new Exception(JText::_('JERROR_LOADFILE_FAILED'));
  369.             }
  370.         }
  371.  
  372.         // Disable home field if it is default style
  373.  
  374.         if ((is_array($data) && array_key_exists('home', $data) && $data['home'] == '1')
  375.             || ((is_object($data) && isset($data->home) && $data->home == '1')))
  376.         {
  377.             $form->setFieldAttribute('home', 'readonly', 'true');
  378.         }
  379.  
  380.         // Attempt to load the xml file.
  381.         if (!$xml = simplexml_load_file($formFile))
  382.         {
  383.             throw new Exception(JText::_('JERROR_LOADFILE_FAILED'));
  384.         }
  385.  
  386.         // Get the help data from the XML file if present.
  387.         $help = $xml->xpath('/extension/help');
  388.  
  389.         if (!empty($help))
  390.         {
  391.             $helpKey = trim((string) $help[0]['key']);
  392.             $helpURL = trim((string) $help[0]['url']);
  393.  
  394.             $this->helpKey = $helpKey ? $helpKey : $this->helpKey;
  395.             $this->helpURL = $helpURL ? $helpURL : $this->helpURL;
  396.         }
  397.  
  398.         // Trigger the default form events.
  399.         parent::preprocessForm($form, $data, $group);
  400.     }
  401.  
  402.     /**
  403.      * Method to save the form data.
  404.      *
  405.      * @param   array  $data  The form data.
  406.      *
  407.      * @return  boolean  True on success.
  408.      */
  409.     public function save($data)
  410.     {
  411.         // Detect disabled extension
  412.         $extension = JTable::getInstance('Extension');
  413.  
  414.         if ($extension->load(array('enabled' => 0, 'type' => 'template', 'element' => $data['template'], 'client_id' => $data['client_id'])))
  415.         {
  416.             $this->setError(JText::_('COM_TEMPLATES_ERROR_SAVE_DISABLED_TEMPLATE'));
  417.  
  418.             return false;
  419.         }
  420.  
  421.         $app        = JFactory::getApplication();
  422.         $dispatcher = JEventDispatcher::getInstance();
  423.         $table      = $this->getTable();
  424.         $pk         = (!empty($data['id'])) ? $data['id'] : (int) $this->getState('style.id');
  425.         $isNew      = true;
  426.  
  427.         // Include the extension plugins for the save events.
  428.         JPluginHelper::importPlugin('extension');
  429.  
  430.         // Load the row if saving an existing record.
  431.         if ($pk > 0)
  432.         {
  433.             $table->load($pk);
  434.             $isNew = false;
  435.         }
  436.  
  437.         if ($app->input->get('task') == 'save2copy')
  438.         {
  439.             $data['title'] = $this->generateNewTitle(null, null, $data['title']);
  440.             $data['home'] = 0;
  441.             $data['assigned'] = '';
  442.         }
  443.  
  444.         // Bind the data.
  445.         if (!$table->bind($data))
  446.         {
  447.             $this->setError($table->getError());
  448.  
  449.             return false;
  450.         }
  451.  
  452.         // Prepare the row for saving
  453.         $this->prepareTable($table);
  454.  
  455.         // Check the data.
  456.         if (!$table->check())
  457.         {
  458.             $this->setError($table->getError());
  459.  
  460.             return false;
  461.         }
  462.  
  463.         // Trigger the onExtensionBeforeSave event.
  464.         $result = $dispatcher->trigger('onExtensionBeforeSave', array('com_templates.style', &$table, $isNew));
  465.  
  466.         if (in_array(false, $result, true))
  467.         {
  468.             $this->setError($table->getError());
  469.  
  470.             return false;
  471.         }
  472.  
  473.         // Store the data.
  474.         if (!$table->store())
  475.         {
  476.             $this->setError($table->getError());
  477.  
  478.             return false;
  479.         }
  480.  
  481.         $user = JFactory::getUser();
  482.  
  483.         if ($user->authorise('core.edit', 'com_menus') && $table->client_id == 0)
  484.         {
  485.             $n    = 0;
  486.             $db   = JFactory::getDbo();
  487.             $user = JFactory::getUser();
  488.  
  489.             if (!empty($data['assigned']) && is_array($data['assigned']))
  490.             {
  491.                 JArrayHelper::toInteger($data['assigned']);
  492.  
  493.                 // Update the mapping for menu items that this style IS assigned to.
  494.                 $query = $db->getQuery(true)
  495.                     ->update('#__menu')
  496.                     ->set('template_style_id = ' . (int) $table->id)
  497.                     ->where('id IN (' . implode(',', $data['assigned']) . ')')
  498.                     ->where('template_style_id != ' . (int) $table->id)
  499.                     ->where('checked_out IN (0,' . (int) $user->id . ')');
  500.                 $db->setQuery($query);
  501.                 $db->execute();
  502.                 $n += $db->getAffectedRows();
  503.             }
  504.  
  505.             // Remove style mappings for menu items this style is NOT assigned to.
  506.             // If unassigned then all existing maps will be removed.
  507.             $query = $db->getQuery(true)
  508.                 ->update('#__menu')
  509.                 ->set('template_style_id = 0');
  510.  
  511.             if (!empty($data['assigned']))
  512.             {
  513.                 $query->where('id NOT IN (' . implode(',', $data['assigned']) . ')');
  514.             }
  515.  
  516.             $query->where('template_style_id = ' . (int) $table->id)
  517.                 ->where('checked_out IN (0,' . (int) $user->id . ')');
  518.             $db->setQuery($query);
  519.             $db->execute();
  520.  
  521.             $n += $db->getAffectedRows();
  522.  
  523.             if ($n > 0)
  524.             {
  525.                 $app->enQueueMessage(JText::plural('COM_TEMPLATES_MENU_CHANGED', $n));
  526.             }
  527.         }
  528.  
  529.         // Clean the cache.
  530.         $this->cleanCache();
  531.  
  532.         // Trigger the onExtensionAfterSave event.
  533.         $dispatcher->trigger('onExtensionAfterSave', array('com_templates.style', &$table, $isNew));
  534.  
  535.         $this->setState('style.id', $table->id);
  536.  
  537.         return true;
  538.     }
  539.  
  540.     /**
  541.      * Method to set a template style as home.
  542.      *
  543.      * @param   integer  $id  The primary key ID for the style.
  544.      *
  545.      * @return  boolean  True if successful.
  546.      *
  547.      * @throws    Exception
  548.      */
  549.     public function setHome($id = 0)
  550.     {
  551.         $user = JFactory::getUser();
  552.         $db   = $this->getDbo();
  553.  
  554.         // Access checks.
  555.         if (!$user->authorise('core.edit.state', 'com_templates'))
  556.         {
  557.             throw new Exception(JText::_('JLIB_APPLICATION_ERROR_EDITSTATE_NOT_PERMITTED'));
  558.         }
  559.  
  560.         $style = JTable::getInstance('Style', 'TemplatesTable');
  561.  
  562.         if (!$style->load((int) $id))
  563.         {
  564.             throw new Exception(JText::_('COM_TEMPLATES_ERROR_STYLE_NOT_FOUND'));
  565.         }
  566.  
  567.         // Detect disabled extension
  568.         $extension = JTable::getInstance('Extension');
  569.  
  570.         if ($extension->load(array('enabled' => 0, 'type' => 'template', 'element' => $style->template, 'client_id' => $style->client_id)))
  571.         {
  572.             throw new Exception(JText::_('COM_TEMPLATES_ERROR_SAVE_DISABLED_TEMPLATE'));
  573.         }
  574.  
  575.         // Reset the home fields for the client_id.
  576.         $db->setQuery(
  577.             'UPDATE #__template_styles' .
  578.             ' SET home = \'0\'' .
  579.             ' WHERE client_id = ' . (int) $style->client_id .
  580.             ' AND home = \'1\''
  581.         );
  582.         $db->execute();
  583.  
  584.         // Set the new home style.
  585.         $db->setQuery(
  586.             'UPDATE #__template_styles' .
  587.             ' SET home = \'1\'' .
  588.             ' WHERE id = ' . (int) $id
  589.         );
  590.         $db->execute();
  591.  
  592.         // Clean the cache.
  593.         $this->cleanCache();
  594.  
  595.         return true;
  596.     }
  597.  
  598.     /**
  599.      * Method to unset a template style as default for a language.
  600.      *
  601.      * @param   integer  $id  The primary key ID for the style.
  602.      *
  603.      * @return  boolean  True if successful.
  604.      *
  605.      * @throws    Exception
  606.      */
  607.     public function unsetHome($id = 0)
  608.     {
  609.         $user = JFactory::getUser();
  610.         $db   = $this->getDbo();
  611.  
  612.         // Access checks.
  613.         if (!$user->authorise('core.edit.state', 'com_templates'))
  614.         {
  615.             throw new Exception(JText::_('JLIB_APPLICATION_ERROR_EDITSTATE_NOT_PERMITTED'));
  616.         }
  617.  
  618.         // Lookup the client_id.
  619.         $db->setQuery(
  620.             'SELECT client_id, home' .
  621.             ' FROM #__template_styles' .
  622.             ' WHERE id = ' . (int) $id
  623.         );
  624.         $style = $db->loadObject();
  625.  
  626.         if (!is_numeric($style->client_id))
  627.         {
  628.             throw new Exception(JText::_('COM_TEMPLATES_ERROR_STYLE_NOT_FOUND'));
  629.         }
  630.         elseif ($style->home == '1')
  631.         {
  632.             throw new Exception(JText::_('COM_TEMPLATES_ERROR_CANNOT_UNSET_DEFAULT_STYLE'));
  633.         }
  634.  
  635.         // Set the new home style.
  636.         $db->setQuery(
  637.             'UPDATE #__template_styles' .
  638.             ' SET home = \'0\'' .
  639.             ' WHERE id = ' . (int) $id
  640.         );
  641.         $db->execute();
  642.  
  643.         // Clean the cache.
  644.         $this->cleanCache();
  645.  
  646.         return true;
  647.     }
  648.  
  649.     /**
  650.      * Get the necessary data to load an item help screen.
  651.      *
  652.      * @return  object  An object with key, url, and local properties for loading the item help screen.
  653.      *
  654.      * @since   1.6
  655.      */
  656.     public function getHelp()
  657.     {
  658.         return (object) array('key' => $this->helpKey, 'url' => $this->helpURL);
  659.     }
  660.  
  661.     /**
  662.      * Custom clean cache method
  663.      *
  664.      * @param   string   $group      The cache group
  665.      * @param   integer  $client_id  The ID of the client
  666.      *
  667.      * @return  void 
  668.      *
  669.      * @since   1.6
  670.      */
  671.     protected function cleanCache($group = null, $client_id = 0)
  672.     {
  673.         parent::cleanCache('com_templates');
  674.         parent::cleanCache('_system');
  675.     }
  676. }

Documentation generated on Tue, 19 Nov 2013 15:14:40 +0100 by phpDocumentor 1.4.3