Source for file weblink.php

Documentation is available at weblink.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_weblinks
  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.  * Weblinks model.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_weblinks
  17.  * @since       1.5
  18.  */
  19. class WeblinksModelWeblink extends JModelAdmin
  20. {
  21.  
  22.     /**
  23.      * The type alias for this content type.
  24.      *
  25.      * @var      string 
  26.      * @since    3.2
  27.      */
  28.     public $typeAlias = 'com_weblinks.weblink';
  29.  
  30.     /**
  31.      * The prefix to use with controller messages.
  32.      *
  33.      * @var    string 
  34.      * @since  1.6
  35.      */
  36.     protected $text_prefix = 'COM_WEBLINKS';
  37.  
  38.     /**
  39.      * Method to test whether a record can be deleted.
  40.      *
  41.      * @param   object  $record  A record object.
  42.      *
  43.      * @return  boolean  True if allowed to delete the record. Defaults to the permission for the component.
  44.      *
  45.      * @since   1.6
  46.      */
  47.     protected function canDelete($record)
  48.     {
  49.         if (!empty($record->id))
  50.         {
  51.             if ($record->state != -2)
  52.             {
  53.                 return;
  54.             }
  55.             $user = JFactory::getUser();
  56.  
  57.             if ($record->catid)
  58.             {
  59.                 return $user->authorise('core.delete', 'com_weblinks.category.'.(int) $record->catid);
  60.             }
  61.             else
  62.             {
  63.                 return parent::canDelete($record);
  64.             }
  65.         }
  66.     }
  67.  
  68.     /**
  69.      * Method to test whether a record can be deleted.
  70.      *
  71.      * @param   object  $record  A record object.
  72.      *
  73.      * @return  boolean  True if allowed to change the state of the record. Defaults to the permission for the component.
  74.      *
  75.      * @since   1.6
  76.      */
  77.     protected function canEditState($record)
  78.     {
  79.         $user = JFactory::getUser();
  80.  
  81.         if (!empty($record->catid))
  82.         {
  83.             return $user->authorise('core.edit.state', 'com_weblinks.category.'.(int) $record->catid);
  84.         }
  85.         else
  86.         {
  87.             return parent::canEditState($record);
  88.         }
  89.     }
  90.  
  91.     /**
  92.      * Method to get a table object, load it if necessary.
  93.      *
  94.      * @param   string  $type    The table name. Optional.
  95.      * @param   string  $prefix  The class prefix. Optional.
  96.      * @param   array   $config  Configuration array for model. Optional.
  97.      *
  98.      * @return  JTable  A JTable object
  99.      *
  100.      * @since   1.6
  101.      */
  102.     public function getTable($type = 'Weblink', $prefix = 'WeblinksTable', $config = array())
  103.     {
  104.         return JTable::getInstance($type, $prefix, $config);
  105.     }
  106.  
  107.     /**
  108.      * Abstract method for getting the form from the model.
  109.      *
  110.      * @param   array    $data      Data for the form.
  111.      * @param   boolean  $loadData  True if the form is to load its own data (default case), false if not.
  112.      *
  113.      * @return  mixed  A JForm object on success, false on failure
  114.      *
  115.      * @since   1.6
  116.      */
  117.     public function getForm($data = array(), $loadData = true)
  118.     {
  119.         // Get the form.
  120.         $form = $this->loadForm('com_weblinks.weblink', 'weblink', array('control' => 'jform', 'load_data' => $loadData));
  121.  
  122.         if (empty($form))
  123.         {
  124.             return false;
  125.         }
  126.  
  127.         // Determine correct permissions to check.
  128.         if ($this->getState('weblink.id'))
  129.         {
  130.             // Existing record. Can only edit in selected categories.
  131.             $form->setFieldAttribute('catid', 'action', 'core.edit');
  132.         }
  133.         else
  134.         {
  135.             // New record. Can only create in selected categories.
  136.             $form->setFieldAttribute('catid', 'action', 'core.create');
  137.         }
  138.  
  139.         // Modify the form based on access controls.
  140.         if (!$this->canEditState((object) $data))
  141.         {
  142.             // Disable fields for display.
  143.             $form->setFieldAttribute('ordering', 'disabled', 'true');
  144.             $form->setFieldAttribute('state', 'disabled', 'true');
  145.             $form->setFieldAttribute('publish_up', 'disabled', 'true');
  146.             $form->setFieldAttribute('publish_down', 'disabled', 'true');
  147.  
  148.             // Disable fields while saving.
  149.             // The controller has already verified this is a record you can edit.
  150.             $form->setFieldAttribute('ordering', 'filter', 'unset');
  151.             $form->setFieldAttribute('state', 'filter', 'unset');
  152.             $form->setFieldAttribute('publish_up', 'filter', 'unset');
  153.             $form->setFieldAttribute('publish_down', 'filter', 'unset');
  154.         }
  155.  
  156.         return $form;
  157.     }
  158.  
  159.     /**
  160.      * Method to get the data that should be injected in the form.
  161.      *
  162.      * @return  array  The default data is an empty array.
  163.      *
  164.      * @since   1.6
  165.      */
  166.     protected function loadFormData()
  167.     {
  168.         // Check the session for previously entered form data.
  169.         $data = JFactory::getApplication()->getUserState('com_weblinks.edit.weblink.data', array());
  170.  
  171.         if (empty($data))
  172.         {
  173.             $data = $this->getItem();
  174.  
  175.             // Prime some default values.
  176.             if ($this->getState('weblink.id') == 0)
  177.             {
  178.                 $app = JFactory::getApplication();
  179.                 $data->set('catid', $app->input->get('catid', $app->getUserState('com_weblinks.weblinks.filter.category_id'), 'int'));
  180.             }
  181.         }
  182.  
  183.         $this->preprocessData('com_weblinks.weblink', $data);
  184.  
  185.         return $data;
  186.     }
  187.  
  188.     /**
  189.      * Method to get a single record.
  190.      *
  191.      * @param   integer  $pk  The id of the primary key.
  192.      *
  193.      * @return  mixed  Object on success, false on failure.
  194.      *
  195.      * @since   1.6
  196.      */
  197.     public function getItem($pk = null)
  198.     {
  199.         if ($item = parent::getItem($pk))
  200.         {
  201.             // Convert the metadata field to an array.
  202.             $registry = new JRegistry;
  203.             $registry->loadString($item->metadata);
  204.             $item->metadata = $registry->toArray();
  205.  
  206.             // Convert the images field to an array.
  207.             $registry = new JRegistry;
  208.             $registry->loadString($item->images);
  209.             $item->images = $registry->toArray();
  210.  
  211.             if (!empty($item->id))
  212.             {
  213.                 $item->tags = new JHelperTags;
  214.                 $item->tags->getTagIds($item->id, 'com_weblinks.weblink');
  215.                 $item->metadata['tags'] = $item->tags;
  216.             }
  217.         }
  218.  
  219.         return $item;
  220.     }
  221.  
  222.     /**
  223.      * Prepare and sanitise the table data prior to saving.
  224.      *
  225.      * @param   JTable  $table  A reference to a JTable object.
  226.      *
  227.      * @return  void 
  228.      *
  229.      * @since   1.6
  230.      */
  231.     protected function prepareTable($table)
  232.     {
  233.         $date = JFactory::getDate();
  234.         $user = JFactory::getUser();
  235.  
  236.         $table->title = htmlspecialchars_decode($table->title, ENT_QUOTES);
  237.         $table->alias = JApplication::stringURLSafe($table->alias);
  238.  
  239.         if (empty($table->alias))
  240.         {
  241.             $table->alias = JApplication::stringURLSafe($table->title);
  242.         }
  243.  
  244.         if (empty($table->id))
  245.         {
  246.             // Set the values
  247.  
  248.             // Set ordering to the last item if not set
  249.             if (empty($table->ordering))
  250.             {
  251.                 $db = JFactory::getDbo();
  252.                 $db->setQuery('SELECT MAX(ordering) FROM #__weblinks');
  253.                 $max = $db->loadResult();
  254.  
  255.                 $table->ordering = $max + 1;
  256.             }
  257.             else
  258.             {
  259.                 // Set the values
  260.                 $table->modified    = $date->toSql();
  261.                 $table->modified_by = $user->get('id');
  262.             }
  263.         }
  264.  
  265.         // Increment the weblink version number.
  266.         $table->version++;
  267.     }
  268.  
  269.     /**
  270.      * A protected method to get a set of ordering conditions.
  271.      *
  272.      * @param   JTable  $table  A JTable object.
  273.      *
  274.      * @return  array  An array of conditions to add to ordering queries.
  275.      *
  276.      * @since   1.6
  277.      */
  278.     protected function getReorderConditions($table)
  279.     {
  280.         $condition = array();
  281.         $condition[] = 'catid = ' . (int) $table->catid;
  282.  
  283.         return $condition;
  284.     }
  285.  
  286.     /**
  287.      * Method to save the form data.
  288.      *
  289.      * @param   array  $data  The form data.
  290.      *
  291.      * @return  boolean  True on success.
  292.      *
  293.      * @since    3.1
  294.      */
  295.     public function save($data)
  296.     {
  297.         $app = JFactory::getApplication();
  298.  
  299.         // Alter the title for save as copy
  300.         if ($app->input->get('task') == 'save2copy')
  301.         {
  302.             list($name, $alias) = $this->generateNewTitle($data['catid'], $data['alias'], $data['title']);
  303.             $data['title']    = $name;
  304.             $data['alias']    = $alias;
  305.             $data['state']    = 0;
  306.         }
  307.  
  308.         return parent::save($data);
  309.     }
  310.  
  311.     /**
  312.      * Method to change the title & alias.
  313.      *
  314.      * @param   integer  $category_id  The id of the parent.
  315.      * @param   string   $alias        The alias.
  316.      * @param   string   $name         The title.
  317.      *
  318.      * @return  array  Contains the modified title and alias.
  319.      *
  320.      * @since   3.1
  321.      */
  322.     protected function generateNewTitle($category_id, $alias, $name)
  323.     {
  324.         // Alter the title & alias
  325.         $table = $this->getTable();
  326.  
  327.         while ($table->load(array('alias' => $alias, 'catid' => $category_id)))
  328.         {
  329.             if ($name == $table->title)
  330.             {
  331.                 $name = JString::increment($name);
  332.             }
  333.  
  334.             $alias = JString::increment($alias, 'dash');
  335.         }
  336.  
  337.         return array($name, $alias);
  338.     }
  339. }

Documentation generated on Tue, 19 Nov 2013 15:18:29 +0100 by phpDocumentor 1.4.3