AAAAindex.html 0000666 00000000037 15137260030 0006542 0 ustar 00
field.php 0000666 00000032055 15137260030 0006346 0 ustar 00 XML element that describes the form field.
*
* @var SimpleXMLElement
* @since 11.1
*/
protected $element;
/**
* The JForm object of the form attached to the form field.
*
* @var JForm
* @since 11.1
*/
protected $form;
/**
* The form control prefix for field names from the JForm object attached to the form field.
*
* @var string
* @since 11.1
*/
protected $formControl;
/**
* The hidden state for the form field.
*
* @var boolean
* @since 11.1
*/
protected $hidden = false;
/**
* True to translate the field label string.
*
* @var boolean
* @since 11.1
*/
protected $translateLabel = true;
/**
* True to translate the field description string.
*
* @var boolean
* @since 11.1
*/
protected $translateDescription = true;
/**
* The document id for the form field.
*
* @var string
* @since 11.1
*/
protected $id;
/**
* The input for the form field.
*
* @var string
* @since 11.1
*/
protected $input;
/**
* The label for the form field.
*
* @var string
* @since 11.1
*/
protected $label;
/**
* The multiple state for the form field. If true then multiple values are allowed for the
* field. Most often used for list field types.
*
* @var boolean
* @since 11.1
*/
protected $multiple = false;
/**
* The name of the form field.
*
* @var string
* @since 11.1
*/
protected $name;
/**
* The name of the field.
*
* @var string
* @since 11.1
*/
protected $fieldname;
/**
* The group of the field.
*
* @var string
* @since 11.1
*/
protected $group;
/**
* The required state for the form field. If true then there must be a value for the field to
* be considered valid.
*
* @var boolean
* @since 11.1
*/
protected $required = false;
/**
* The form field type.
*
* @var string
* @since 11.1
*/
protected $type;
/**
* The validation method for the form field. This value will determine which method is used
* to validate the value for a field.
*
* @var string
* @since 11.1
*/
protected $validate;
/**
* The value of the form field.
*
* @var mixed
* @since 11.1
*/
protected $value;
/**
* The label's CSS class of the form field
*
* @var mixed
* @since 11.1
*/
protected $labelClass;
/**
* The count value for generated name field
*
* @var integer
* @since 11.1
*/
protected static $count = 0;
/**
* The string used for generated fields names
*
* @var integer
* @since 11.1
*/
protected static $generated_fieldname = '__field';
/**
* Method to instantiate the form field object.
*
* @param object $form The form to attach to the form field object.
*
* @since 11.1
*/
public function __construct($form = null)
{
// If there is a form passed into the constructor set the form and form control properties.
if ($form instanceof JForm)
{
$this->form = $form;
$this->formControl = $form->getFormControl();
}
// Detect the field type if not set
if (!isset($this->type))
{
$parts = JString::splitCamelCase(get_class($this));
if ($parts[0] == 'J')
{
$this->type = JString::ucfirst($parts[count($parts) - 1], '_');
}
else
{
$this->type = JString::ucfirst($parts[0], '_') . JString::ucfirst($parts[count($parts) - 1], '_');
}
}
}
/**
* Method to get certain otherwise inaccessible properties from the form field object.
*
* @param string $name The property name for which to the the value.
*
* @return mixed The property value or null.
*
* @since 11.1
*/
public function __get($name)
{
switch ($name)
{
case 'class':
case 'description':
case 'formControl':
case 'hidden':
case 'id':
case 'multiple':
case 'name':
case 'required':
case 'type':
case 'validate':
case 'value':
case 'labelClass':
case 'fieldname':
case 'group':
return $this->$name;
break;
case 'input':
// If the input hasn't yet been generated, generate it.
if (empty($this->input))
{
$this->input = $this->getInput();
}
return $this->input;
break;
case 'label':
// If the label hasn't yet been generated, generate it.
if (empty($this->label))
{
$this->label = $this->getLabel();
}
return $this->label;
break;
case 'title':
return $this->getTitle();
break;
}
return null;
}
/**
* Method to attach a JForm object to the field.
*
* @param JForm $form The JForm object to attach to the form field.
*
* @return object The form field object so that the method can be used in a chain.
*
* @since 11.1
*/
public function setForm(JForm $form)
{
$this->form = $form;
$this->formControl = $form->getFormControl();
return $this;
}
/**
* Method to attach a JForm object to the field.
*
* @param object &$element The SimpleXMLElement object representing the tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
*
* @return boolean True on success.
*
* @since 11.1
*/
public function setup(&$element, $value, $group = null)
{
// Make sure there is a valid JFormField XML element.
if (!($element instanceof SimpleXMLElement) || (string) $element->getName() != 'field')
{
return false;
}
// Reset the input and label values.
$this->input = null;
$this->label = null;
// Set the XML element object.
$this->element = $element;
// Get some important attributes from the form field element.
$class = (string) $element['class'];
$id = (string) $element['id'];
$multiple = (string) $element['multiple'];
$name = (string) $element['name'];
$required = (string) $element['required'];
// Set the required and validation options.
$this->required = ($required == 'true' || $required == 'required' || $required == '1');
$this->validate = (string) $element['validate'];
// Add the required class if the field is required.
if ($this->required)
{
if ($class)
{
if (strpos($class, 'required') === false)
{
$this->element['class'] = $class . ' required';
}
}
else
{
$this->element->addAttribute('class', 'required');
}
}
// Set the multiple values option.
$this->multiple = ($multiple == 'true' || $multiple == 'multiple');
// Allow for field classes to force the multiple values option.
if (isset($this->forceMultiple))
{
$this->multiple = (bool) $this->forceMultiple;
}
// Set the field description text.
$this->description = (string) $element['description'];
// Set the visibility.
$this->hidden = ((string) $element['type'] == 'hidden' || (string) $element['hidden'] == 'true');
// Determine whether to translate the field label and/or description.
$this->translateLabel = !((string) $this->element['translate_label'] == 'false' || (string) $this->element['translate_label'] == '0');
$this->translateDescription = !((string) $this->element['translate_description'] == 'false'
|| (string) $this->element['translate_description'] == '0');
// Set the group of the field.
$this->group = $group;
// Set the field name and id.
$this->fieldname = $this->getFieldName($name);
$this->name = $this->getName($this->fieldname);
$this->id = $this->getId($id, $this->fieldname);
// Set the field default value.
$this->value = $value;
// Set the CSS class of field label
$this->labelClass = (string) $element['labelclass'];
return true;
}
/**
* Method to get the id used for the field input tag.
*
* @param string $fieldId The field element id.
* @param string $fieldName The field element name.
*
* @return string The id to be used for the field input tag.
*
* @since 11.1
*/
protected function getId($fieldId, $fieldName)
{
// Initialise variables.
$id = '';
// If there is a form control set for the attached form add it first.
if ($this->formControl)
{
$id .= $this->formControl;
}
// If the field is in a group add the group control to the field id.
if ($this->group)
{
// If we already have an id segment add the group control as another level.
if ($id)
{
$id .= '_' . str_replace('.', '_', $this->group);
}
else
{
$id .= str_replace('.', '_', $this->group);
}
}
// If we already have an id segment add the field id/name as another level.
if ($id)
{
$id .= '_' . ($fieldId ? $fieldId : $fieldName);
}
else
{
$id .= ($fieldId ? $fieldId : $fieldName);
}
// Clean up any invalid characters.
$id = preg_replace('#\W#', '_', $id);
return $id;
}
/**
* Method to get the field input markup.
*
* @return string The field input markup.
*
* @since 11.1
*/
abstract protected function getInput();
/**
* Method to get the field title.
*
* @return string The field title.
*
* @since 11.1
*/
protected function getTitle()
{
// Initialise variables.
$title = '';
if ($this->hidden)
{
return $title;
}
// Get the label text from the XML element, defaulting to the element name.
$title = $this->element['label'] ? (string) $this->element['label'] : (string) $this->element['name'];
$title = $this->translateLabel ? JText::_($title) : $title;
return $title;
}
/**
* Method to get the field label markup.
*
* @return string The field label markup.
*
* @since 11.1
*/
protected function getLabel()
{
// Initialise variables.
$label = '';
if ($this->hidden)
{
return $label;
}
// Get the label text from the XML element, defaulting to the element name.
$text = $this->element['label'] ? (string) $this->element['label'] : (string) $this->element['name'];
$text = $this->translateLabel ? JText::_($text) : $text;
// Build the class for the label.
$class = !empty($this->description) ? 'hasTip' : '';
$class = $this->required == true ? $class . ' required' : $class;
$class = !empty($this->labelClass) ? $class . ' ' . $this->labelClass : $class;
// Add the opening label tag and main attributes attributes.
$label .= '';
}
else
{
$label .= '>' . $text . '';
}
return $label;
}
/**
* Method to get the name used for the field input tag.
*
* @param string $fieldName The field element name.
*
* @return string The name to be used for the field input tag.
*
* @since 11.1
*/
protected function getName($fieldName)
{
// Initialise variables.
$name = '';
// If there is a form control set for the attached form add it first.
if ($this->formControl)
{
$name .= $this->formControl;
}
// If the field is in a group add the group control to the field name.
if ($this->group)
{
// If we already have a name segment add the group control as another level.
$groups = explode('.', $this->group);
if ($name)
{
foreach ($groups as $group)
{
$name .= '[' . $group . ']';
}
}
else
{
$name .= array_shift($groups);
foreach ($groups as $group)
{
$name .= '[' . $group . ']';
}
}
}
// If we already have a name segment add the field name as another level.
if ($name)
{
$name .= '[' . $fieldName . ']';
}
else
{
$name .= $fieldName;
}
// If the field should support multiple values add the final array segment.
if ($this->multiple)
{
$name .= '[]';
}
return $name;
}
/**
* Method to get the field name used.
*
* @param string $fieldName The field element name.
*
* @return string The field name
*
* @since 11.1
*/
protected function getFieldName($fieldName)
{
if ($fieldName)
{
return $fieldName;
}
else
{
self::$count = self::$count + 1;
return self::$generated_fieldname . self::$count;
}
}
}
fields/folderlist.php 0000666 00000004346 15137260030 0010702 0 ustar 00 element['filter'];
$exclude = (string) $this->element['exclude'];
$hideNone = (string) $this->element['hide_none'];
$hideDefault = (string) $this->element['hide_default'];
// Get the path in which to search for file options.
$path = (string) $this->element['directory'];
if (!is_dir($path))
{
$path = JPATH_ROOT . '/' . $path;
}
// Prepend some default options based on field attributes.
if (!$hideNone)
{
$options[] = JHtml::_('select.option', '-1', JText::alt('JOPTION_DO_NOT_USE', preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)));
}
if (!$hideDefault)
{
$options[] = JHtml::_('select.option', '', JText::alt('JOPTION_USE_DEFAULT', preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)));
}
// Get a list of folders in the search path with the given filter.
$folders = JFolder::folders($path, $filter);
// Build the options list from the list of folders.
if (is_array($folders))
{
foreach ($folders as $folder)
{
// Check to see if the file is in the exclude mask.
if ($exclude)
{
if (preg_match(chr(1) . $exclude . chr(1), $folder))
{
continue;
}
}
$options[] = JHtml::_('select.option', $folder, $folder);
}
}
// Merge any additional options in the XML definition.
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
fields/menuitem.php 0000666 00000004531 15137260030 0010352 0 ustar 00 element['menu_type'];
$published = $this->element['published'] ? explode(',', (string) $this->element['published']) : array();
$disable = $this->element['disable'] ? explode(',', (string) $this->element['disable']) : array();
$language = $this->element['language'] ? explode(',', (string) $this->element['language']) : array();
// Get the menu items.
$items = MenusHelper::getMenuLinks($menuType, 0, 0, $published, $language);
// Build group for a specific menu type.
if ($menuType)
{
// Initialize the group.
$groups[$menuType] = array();
// Build the options array.
foreach ($items as $link)
{
$groups[$menuType][] = JHtml::_('select.option', $link->value, $link->text, 'value', 'text', in_array($link->type, $disable));
}
}
// Build groups for all menu types.
else
{
// Build the groups arrays.
foreach ($items as $menu)
{
// Initialize the group.
$groups[$menu->menutype] = array();
// Build the options array.
foreach ($menu->links as $link)
{
$groups[$menu->menutype][] = JHtml::_(
'select.option', $link->value, $link->text, 'value', 'text',
in_array($link->type, $disable)
);
}
}
}
// Merge any additional groups in the XML definition.
$groups = array_merge(parent::getGroups(), $groups);
return $groups;
}
}
fields/textarea.php 0000666 00000003234 15137260030 0010343 0 ustar 00 element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$disabled = ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
$columns = $this->element['cols'] ? ' cols="' . (int) $this->element['cols'] . '"' : '';
$rows = $this->element['rows'] ? ' rows="' . (int) $this->element['rows'] . '"' : '';
// Initialize JavaScript field attributes.
$onchange = $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
return '';
}
}
fields/text.php 0000666 00000003441 15137260030 0007512 0 ustar 00 element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$maxLength = $this->element['maxlength'] ? ' maxlength="' . (int) $this->element['maxlength'] . '"' : '';
$class = $this->element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$auto = ((string) $this->element['autocomplete'] == 'off') ? ' autocomplete="off"' : '';
$readonly = ((string) $this->element['readonly'] == 'true') ? ' readonly="readonly"' : '';
$disabled = ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
// Initialize JavaScript field attributes.
$onchange = $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
return '';
}
}
fields/spacer.php 0000666 00000005275 15137260030 0010012 0 ustar 00 element['class'] ? (string) $this->element['class'] : '';
$html[] = '';
$html[] = '';
$html[] = '';
if ((string) $this->element['hr'] == 'true')
{
$html[] = '';
}
else
{
$label = '';
// Get the label text from the XML element, defaulting to the element name.
$text = $this->element['label'] ? (string) $this->element['label'] : (string) $this->element['name'];
$text = $this->translateLabel ? JText::_($text) : $text;
// Build the class for the label.
$class = !empty($this->description) ? 'hasTip' : '';
$class = $this->required == true ? $class . ' required' : $class;
// Add the opening label tag and main attributes attributes.
$label .= '';
$html[] = $label;
}
$html[] = '';
$html[] = '';
$html[] = '';
return implode('', $html);
}
/**
* Method to get the field title.
*
* @return string The field title.
*
* @since 11.1
*/
protected function getTitle()
{
return $this->getLabel();
}
}
fields/calendar.php 0000666 00000005526 15137260030 0010305 0 ustar 00 element['format'] ? (string) $this->element['format'] : '%Y-%m-%d';
// Build the attributes array.
$attributes = array();
if ($this->element['size'])
{
$attributes['size'] = (int) $this->element['size'];
}
if ($this->element['maxlength'])
{
$attributes['maxlength'] = (int) $this->element['maxlength'];
}
if ($this->element['class'])
{
$attributes['class'] = (string) $this->element['class'];
}
if ((string) $this->element['readonly'] == 'true')
{
$attributes['readonly'] = 'readonly';
}
if ((string) $this->element['disabled'] == 'true')
{
$attributes['disabled'] = 'disabled';
}
if ($this->element['onchange'])
{
$attributes['onchange'] = (string) $this->element['onchange'];
}
// Handle the special case for "now".
if (strtoupper($this->value) == 'NOW')
{
$this->value = strftime($format);
}
// Get some system objects.
$config = JFactory::getConfig();
$user = JFactory::getUser();
// If a known filter is given use it.
switch (strtoupper((string) $this->element['filter']))
{
case 'SERVER_UTC':
// Convert a date to UTC based on the server timezone.
if (intval($this->value))
{
// Get a date object based on the correct timezone.
$date = JFactory::getDate($this->value, 'UTC');
$date->setTimezone(new DateTimeZone($config->get('offset')));
// Transform the date string.
$this->value = $date->format('Y-m-d H:i:s', true, false);
}
break;
case 'USER_UTC':
// Convert a date to UTC based on the user timezone.
if (intval($this->value))
{
// Get a date object based on the correct timezone.
$date = JFactory::getDate($this->value, 'UTC');
$date->setTimezone(new DateTimeZone($user->getParam('timezone', $config->get('offset'))));
// Transform the date string.
$this->value = $date->format('Y-m-d H:i:s', true, false);
}
break;
}
return JHtml::_('calendar', $this->value, $this->name, $this->id, $format, $attributes);
}
}
fields/file.php 0000666 00000003345 15137260030 0007450 0 ustar 00 element['accept'] ? ' accept="' . (string) $this->element['accept'] . '"' : '';
$size = $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$class = $this->element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$disabled = ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
// Initialize JavaScript field attributes.
$onchange = $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
return '';
}
}
fields/rules.php 0000666 00000025165 15137260030 0007667 0 ustar 00 element['section'] ? (string) $this->element['section'] : '';
$component = $this->element['component'] ? (string) $this->element['component'] : '';
$assetField = $this->element['asset_field'] ? (string) $this->element['asset_field'] : 'asset_id';
// Get the actions for the asset.
$actions = JAccess::getActions($component, $section);
// Iterate over the children and add to the actions.
foreach ($this->element->children() as $el)
{
if ($el->getName() == 'action')
{
$actions[] = (object) array('name' => (string) $el['name'], 'title' => (string) $el['title'],
'description' => (string) $el['description']);
}
}
// Get the explicit rules for this asset.
if ($section == 'component')
{
// Need to find the asset id by the name of the component.
$db = JFactory::getDbo();
$query = $db->getQuery(true);
$query->select($db->quoteName('id'));
$query->from($db->quoteName('#__assets'));
$query->where($db->quoteName('name') . ' = ' . $db->quote($component));
$db->setQuery($query);
$assetId = (int) $db->loadResult();
if ($error = $db->getErrorMsg())
{
JError::raiseNotice(500, $error);
}
}
else
{
// Find the asset id of the content.
// Note that for global configuration, com_config injects asset_id = 1 into the form.
$assetId = $this->form->getValue($assetField);
}
// Use the compact form for the content rules (deprecated).
//if (!empty($component) && $section != 'component') {
// return JHtml::_('rules.assetFormWidget', $actions, $assetId, $assetId ? null : $component, $this->name, $this->id);
//}
// Full width format.
// Get the rules for just this asset (non-recursive).
$assetRules = JAccess::getAssetRules($assetId);
// Get the available user groups.
$groups = $this->getUserGroups();
// Build the form control.
$curLevel = 0;
// Prepare output
$html = array();
$html[] = '
';
$html[] = '
' . JText::_('JLIB_RULES_SETTINGS_DESC') . '
';
$html[] = '
';
// Start a row for each user group.
foreach ($groups as $group)
{
$difLevel = $group->level - $curLevel;
if ($difLevel > 0)
{
$html[] = '
';
// The calculated setting is not shown for the root group of global configuration.
$canCalculateSettings = ($group->parent_id || !empty($component));
if ($canCalculateSettings)
{
$html[] = '
';
$html[] = ' ';
// If this asset's rule is allowed, but the inherited rule is deny, we have a conflict.
if (($assetRule === true) && ($inheritedRule === false))
{
$html[] = JText::_('JLIB_RULES_CONFLICT');
}
$html[] = '
';
// Build the Calculated Settings column.
// The inherited settings column is not displayed for the root group in global configuration.
if ($canCalculateSettings)
{
$html[] = '
';
// This is where we show the current effective settings considering currrent group, path and cascade.
// Check whether this is a component or global. Change the text slightly.
if (JAccess::checkGroup($group->value, 'core.admin', $assetId) !== true)
{
if ($inheritedRule === null)
{
$html[] = '' . JText::_('JLIB_RULES_NOT_ALLOWED') . '';
}
elseif ($inheritedRule === true)
{
$html[] = '' . JText::_('JLIB_RULES_ALLOWED') . '';
}
elseif ($inheritedRule === false)
{
if ($assetRule === false)
{
$html[] = '' . JText::_('JLIB_RULES_NOT_ALLOWED') . '';
}
else
{
$html[] = '' . JText::_('JLIB_RULES_NOT_ALLOWED_LOCKED')
. '';
}
}
}
elseif (!empty($component))
{
$html[] = '' . JText::_('JLIB_RULES_ALLOWED_ADMIN')
. '';
}
else
{
// Special handling for groups that have global admin because they can't be denied.
// The admin rights can be changed.
if ($action->name === 'core.admin')
{
$html[] = '' . JText::_('JLIB_RULES_ALLOWED') . '';
}
elseif ($inheritedRule === false)
{
// Other actions cannot be changed.
$html[] = ''
. JText::_('JLIB_RULES_NOT_ALLOWED_ADMIN_CONFLICT') . '';
}
else
{
$html[] = '' . JText::_('JLIB_RULES_ALLOWED_ADMIN')
. '';
}
}
$html[] = '
';
}
return implode("\n", $html);
}
}
fields/editors.php 0000666 00000004066 15137260030 0010203 0 ustar 00 getQuery(true);
// Build the query.
$query->select('element AS value, name AS text');
$query->from('#__extensions');
$query->where('folder = ' . $db->quote('editors'));
$query->where('enabled = 1');
$query->order('ordering, name');
// Set the query and load the options.
$db->setQuery($query);
$options = $db->loadObjectList();
$lang = JFactory::getLanguage();
foreach ($options as $i => $option)
{
$lang->load('plg_editors_' . $option->value, JPATH_ADMINISTRATOR, null, false, true)
|| $lang->load('plg_editors_' . $option->value, JPATH_PLUGINS . '/editors/' . $option->value, null, false, true);
$options[$i]->text = JText::_($option->text);
}
// Check for a database error.
if ($db->getErrorNum())
{
JError::raiseWarning(500, $db->getErrorMsg());
}
// Merge any additional options in the XML definition.
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
fields/list.php 0000666 00000006104 15137260030 0007500 0 ustar 00 element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
// To avoid user's confusion, readonly="true" should imply disabled="true".
if ((string) $this->element['readonly'] == 'true' || (string) $this->element['disabled'] == 'true')
{
$attr .= ' disabled="disabled"';
}
$attr .= $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$attr .= $this->multiple ? ' multiple="multiple"' : '';
// Initialize JavaScript field attributes.
$attr .= $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
// Get the field options.
$options = (array) $this->getOptions();
// Create a read-only list (no name) with a hidden input to store the value.
if ((string) $this->element['readonly'] == 'true')
{
$html[] = JHtml::_('select.genericlist', $options, '', trim($attr), 'value', 'text', $this->value, $this->id);
$html[] = '';
}
// Create a regular list.
else
{
$html[] = JHtml::_('select.genericlist', $options, $this->name, trim($attr), 'value', 'text', $this->value, $this->id);
}
return implode($html);
}
/**
* Method to get the field options.
*
* @return array The field option objects.
*
* @since 11.1
*/
protected function getOptions()
{
// Initialize variables.
$options = array();
foreach ($this->element->children() as $option)
{
// Only add elements.
if ($option->getName() != 'option')
{
continue;
}
// Create a new option object based on the element.
$tmp = JHtml::_(
'select.option', (string) $option['value'],
JText::alt(trim((string) $option), preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)), 'value', 'text',
((string) $option['disabled'] == 'true')
);
// Set some option attributes.
$tmp->class = (string) $option['class'];
// Set some JavaScript option attributes.
$tmp->onclick = (string) $option['onclick'];
// Add the option object to the result set.
$options[] = $tmp;
}
reset($options);
return $options;
}
}
fields/category.php 0000666 00000007300 15137260030 0010341 0 ustar 00 element['extension'] ? (string) $this->element['extension'] : (string) $this->element['scope'];
$published = (string) $this->element['published'];
$name = (string) $this->element['name'];
// Load the category options for a given extension.
if (!empty($extension))
{
// Filter over published state or not depending upon if it is present.
if ($published)
{
$options = JHtml::_('category.options', $extension, array('filter.published' => explode(',', $published)));
}
else
{
$options = JHtml::_('category.options', $extension);
}
// Verify permissions. If the action attribute is set, then we scan the options.
if ((string) $this->element['action'])
{
// Get the current user object.
$user = JFactory::getUser();
// For new items we want a list of categories you are allowed to create in.
if (!$this->form->getValue($name))
{
foreach ($options as $i => $option) {
// To take save or create in a category you need to have create rights for that category
// unless the item is already in that category.
// Unset the option if the user isn't authorised for it. In this field assets are always categories.
if ($user->authorise('core.create', $extension . '.category.' . $option->value) != true )
{
unset($options[$i]);
}
}
}
// If you have an existing category id things are more complex.
else
{
$categoryOld = $this->form->getValue($name);
foreach ($options as $i => $option)
{
// If you are only allowed to edit in this category but not edit.state, you should not get any
// option to change the category.
if ($user->authorise('core.edit.state', $extension . '.category.' . $categoryOld) != true)
{
if ($option->value != $categoryOld)
{
unset($options[$i]);
}
}
// However, if you can edit.state you can also move this to another category for which you have
// create permission and you should also still be able to save in the current category.
elseif
(($user->authorise('core.create', $extension . '.category.' . $option->value) != true)
&& $option->value != $categoryOld)
{
unset($options[$i]);
}
}
}
}
if (isset($this->element['show_root']))
{
array_unshift($options, JHtml::_('select.option', '0', JText::_('JGLOBAL_ROOT')));
}
}
else
{
JError::raiseWarning(500, JText::_('JLIB_FORM_ERROR_FIELDS_CATEGORY_ERROR_EXTENSION_EMPTY'));
}
// Merge any additional options in the XML definition.
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
fields/databaseconnection.php 0000666 00000004034 15137260030 0012351 0 ustar 00 element['supported'];
if (!empty($supported))
{
$supported = explode(',', $supported);
foreach ($supported as $support)
{
if (in_array($support, $available))
{
$options[$support] = ucfirst($support);
}
}
}
else
{
foreach ($available as $support)
{
$options[$support] = ucfirst($support);
}
}
// This will come into play if an application is installed that requires
// a database that is not available on the server.
if (empty($options))
{
$options[''] = JText::_('JNONE');
}
return $options;
}
}
fields/.htaccess 0000666 00000000177 15137260030 0007616 0 ustar 00
Order allow,deny
Deny from all
fields/componentlayout.php 0000666 00000016432 15137260030 0011772 0 ustar 00 element['client_id'];
if (is_null($clientId) && $this->form instanceof JForm)
{
$clientId = $this->form->getValue('client_id');
}
$clientId = (int) $clientId;
$client = JApplicationHelper::getClientInfo($clientId);
// Get the extension.
$extn = (string) $this->element['extension'];
if (empty($extn) && ($this->form instanceof JForm))
{
$extn = $this->form->getValue('extension');
}
$extn = preg_replace('#\W#', '', $extn);
// Get the template.
$template = (string) $this->element['template'];
$template = preg_replace('#\W#', '', $template);
// Get the style.
if ($this->form instanceof JForm)
{
$template_style_id = $this->form->getValue('template_style_id');
}
$template_style_id = preg_replace('#\W#', '', $template_style_id);
// Get the view.
$view = (string) $this->element['view'];
$view = preg_replace('#\W#', '', $view);
// If a template, extension and view are present build the options.
if ($extn && $view && $client)
{
// Load language file
$lang = JFactory::getLanguage();
$lang->load($extn . '.sys', JPATH_ADMINISTRATOR, null, false, true)
|| $lang->load($extn . '.sys', JPATH_ADMINISTRATOR . '/components/' . $extn, null, false, true);
// Get the database object and a new query object.
$db = JFactory::getDBO();
$query = $db->getQuery(true);
// Build the query.
$query->select('e.element, e.name');
$query->from('#__extensions as e');
$query->where('e.client_id = ' . (int) $clientId);
$query->where('e.type = ' . $db->quote('template'));
$query->where('e.enabled = 1');
if ($template)
{
$query->where('e.element = ' . $db->quote($template));
}
if ($template_style_id)
{
$query->join('LEFT', '#__template_styles as s on s.template=e.element');
$query->where('s.id=' . (int) $template_style_id);
}
// Set the query and load the templates.
$db->setQuery($query);
$templates = $db->loadObjectList('element');
// Check for a database error.
if ($db->getErrorNum())
{
JError::raiseWarning(500, $db->getErrorMsg());
}
// Build the search paths for component layouts.
$component_path = JPath::clean($client->path . '/components/' . $extn . '/views/' . $view . '/tmpl');
// Prepare array of component layouts
$component_layouts = array();
// Prepare the grouped list
$groups = array();
// Add a Use Global option if useglobal="true" in XML file
if ($this->element['useglobal'] == 'true')
{
$groups[JText::_('JOPTION_FROM_STANDARD')]['items'][] = JHtml::_('select.option', '', JText::_('JGLOBAL_USE_GLOBAL'));
}
// Add the layout options from the component path.
if (is_dir($component_path) && ($component_layouts = JFolder::files($component_path, '^[^_]*\.xml$', false, true)))
{
// Create the group for the component
$groups['_'] = array();
$groups['_']['id'] = $this->id . '__';
$groups['_']['text'] = JText::sprintf('JOPTION_FROM_COMPONENT');
$groups['_']['items'] = array();
foreach ($component_layouts as $i => $file)
{
// Attempt to load the XML file.
if (!$xml = simplexml_load_file($file))
{
unset($component_layouts[$i]);
continue;
}
// Get the help data from the XML file if present.
if (!$menu = $xml->xpath('layout[1]'))
{
unset($component_layouts[$i]);
continue;
}
$menu = $menu[0];
// Add an option to the component group
$value = JFile::stripext(JFile::getName($file));
$component_layouts[$i] = $value;
$text = isset($menu['option']) ? JText::_($menu['option']) : (isset($menu['title']) ? JText::_($menu['title']) : $value);
$groups['_']['items'][] = JHtml::_('select.option', '_:' . $value, $text);
}
}
// Loop on all templates
if ($templates)
{
foreach ($templates as $template)
{
// Load language file
$lang->load('tpl_' . $template->element . '.sys', $client->path, null, false, true)
|| $lang->load('tpl_' . $template->element . '.sys', $client->path . '/templates/' . $template->element, null, false, true);
$template_path = JPath::clean($client->path . '/templates/' . $template->element . '/html/' . $extn . '/' . $view);
// Add the layout options from the template path.
if (is_dir($template_path) && ($files = JFolder::files($template_path, '^[^_]*\.php$', false, true)))
{
// Files with corresponding XML files are alternate menu items, not alternate layout files
// so we need to exclude these files from the list.
$xml_files = JFolder::files($template_path, '^[^_]*\.xml$', false, true);
for ($j = 0, $count = count($xml_files); $j < $count; $j++)
{
$xml_files[$j] = JFile::stripext(JFile::getName($xml_files[$j]));
}
foreach ($files as $i => $file)
{
// Remove layout files that exist in the component folder or that have XML files
if ((in_array(JFile::stripext(JFile::getName($file)), $component_layouts))
|| (in_array(JFile::stripext(JFile::getName($file)), $xml_files)))
{
unset($files[$i]);
}
}
if (count($files))
{
// Create the group for the template
$groups[$template->name] = array();
$groups[$template->name]['id'] = $this->id . '_' . $template->element;
$groups[$template->name]['text'] = JText::sprintf('JOPTION_FROM_TEMPLATE', $template->name);
$groups[$template->name]['items'] = array();
foreach ($files as $file)
{
// Add an option to the template group
$value = JFile::stripext(JFile::getName($file));
$text = $lang
->hasKey($key = strtoupper('TPL_' . $template->name . '_' . $extn . '_' . $view . '_LAYOUT_' . $value))
? JText::_($key) : $value;
$groups[$template->name]['items'][] = JHtml::_('select.option', $template->element . ':' . $value, $text);
}
}
}
}
}
// Compute attributes for the grouped list
$attr = $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
// Prepare HTML code
$html = array();
// Compute the current selected values
$selected = array($this->value);
// Add a grouped list
$html[] = JHtml::_(
'select.groupedlist', $groups, $this->name,
array('id' => $this->id, 'group.id' => 'id', 'list.attr' => $attr, 'list.select' => $selected)
);
return implode($html);
}
else
{
return '';
}
}
}
fields/plugins.php 0000666 00000003741 15137260030 0010212 0 ustar 00 element['folder'];
if (!empty($folder))
{
// Get list of plugins
$db = JFactory::getDbo();
$query = $db->getQuery(true);
$query->select('element AS value, name AS text');
$query->from('#__extensions');
$query->where('folder = ' . $db->q($folder));
$query->where('enabled = 1');
$query->order('ordering, name');
$db->setQuery($query);
$options = $db->loadObjectList();
$lang = JFactory::getLanguage();
foreach ($options as $i => $item)
{
$source = JPATH_PLUGINS . '/' . $folder . '/' . $item->value;
$extension = 'plg_' . $folder . '_' . $item->value;
$lang->load($extension . '.sys', JPATH_ADMINISTRATOR, null, false, true)
|| $lang->load($extension . '.sys', $source, null, false, true);
$options[$i]->text = JText::_($item->text);
}
if ($db->getErrorMsg())
{
JError::raiseWarning(500, JText::_('JFRAMEWORK_FORM_FIELDS_PLUGINS_ERROR_FOLDER_EMPTY'));
return '';
}
}
else
{
JError::raiseWarning(500, JText::_('JFRAMEWORK_FORM_FIELDS_PLUGINS_ERROR_FOLDER_EMPTY'));
}
// Merge any additional options in the XML definition.
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
fields/combo.php 0000666 00000003766 15137260030 0007637 0 ustar 00 element['class'] ? ' class="combobox ' . (string) $this->element['class'] . '"' : ' class="combobox"';
$attr .= ((string) $this->element['readonly'] == 'true') ? ' readonly="readonly"' : '';
$attr .= ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
$attr .= $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
// Initialize JavaScript field attributes.
$attr .= $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
// Get the field options.
$options = $this->getOptions();
// Load the combobox behavior.
JHtml::_('behavior.combobox');
// Build the input for the combo box.
$html[] = '';
// Build the list for the combo box.
$html[] = '
';
foreach ($options as $option)
{
$html[] = '
' . $option->text . '
';
}
$html[] = '
';
return implode($html);
}
}
fields/usergroup.php 0000666 00000004230 15137260030 0010556 0 ustar 00 element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$attr .= ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
$attr .= $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$attr .= $this->multiple ? ' multiple="multiple"' : '';
// Initialize JavaScript field attributes.
$attr .= $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
// Iterate through the children and build an array of options.
foreach ($this->element->children() as $option)
{
// Only add elements.
if ($option->getName() != 'option')
{
continue;
}
// Create a new option object based on the element.
$tmp = JHtml::_(
'select.option', (string) $option['value'], trim((string) $option), 'value', 'text',
((string) $option['disabled'] == 'true')
);
// Set some option attributes.
$tmp->class = (string) $option['class'];
// Set some JavaScript option attributes.
$tmp->onclick = (string) $option['onclick'];
// Add the option object to the result set.
$options[] = $tmp;
}
return JHtml::_('access.usergroup', $this->name, $this->value, $attr, $options, $this->id);
}
}
fields/filelist.php 0000666 00000005222 15137260030 0010340 0 ustar 00 element['filter'];
$exclude = (string) $this->element['exclude'];
$stripExt = (string) $this->element['stripext'];
$hideNone = (string) $this->element['hide_none'];
$hideDefault = (string) $this->element['hide_default'];
// Get the path in which to search for file options.
$path = (string) $this->element['directory'];
if (!is_dir($path))
{
$path = JPATH_ROOT . '/' . $path;
}
// Prepend some default options based on field attributes.
if (!$hideNone)
{
$options[] = JHtml::_('select.option', '-1', JText::alt('JOPTION_DO_NOT_USE', preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)));
}
if (!$hideDefault)
{
$options[] = JHtml::_('select.option', '', JText::alt('JOPTION_USE_DEFAULT', preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)));
}
// Get a list of files in the search path with the given filter.
$files = JFolder::files($path, $filter);
// Build the options list from the list of files.
if (is_array($files))
{
foreach ($files as $file)
{
// Check to see if the file is in the exclude mask.
if ($exclude)
{
if (preg_match(chr(1) . $exclude . chr(1), $file))
{
continue;
}
}
// If the extension is to be stripped, do it.
if ($stripExt)
{
$file = JFile::stripExt($file);
}
$options[] = JHtml::_('select.option', $file, $file);
}
}
// Merge any additional options in the XML definition.
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
fields/language.php 0000666 00000002426 15137260030 0010313 0 ustar 00 element['client'];
if ($client != 'site' && $client != 'administrator')
{
$client = 'site';
}
// Merge any additional options in the XML definition.
$options = array_merge(
parent::getOptions(),
JLanguageHelper::createLanguageList($this->value, constant('JPATH_' . strtoupper($client)), true, true)
);
return $options;
}
}
fields/timezone.php 0000666 00000004611 15137260030 0010360 0 ustar 00 element['key_field'] ? (string) $this->element['key_field'] : 'id';
$keyValue = $this->form->getValue($keyField);
// If the timezone is not set use the server setting.
if (strlen($this->value) == 0 && empty($keyValue))
{
$this->value = JFactory::getConfig()->get('offset');
}
// Get the list of time zones from the server.
$zones = DateTimeZone::listIdentifiers();
// Build the group lists.
foreach ($zones as $zone)
{
// Time zones not in a group we will ignore.
if (strpos($zone, '/') === false)
{
continue;
}
// Get the group/locale from the timezone.
list ($group, $locale) = explode('/', $zone, 2);
// Only use known groups.
if (in_array($group, self::$zones))
{
// Initialize the group if necessary.
if (!isset($groups[$group]))
{
$groups[$group] = array();
}
// Only add options where a locale exists.
if (!empty($locale))
{
$groups[$group][$zone] = JHtml::_('select.option', $zone, str_replace('_', ' ', $locale), 'value', 'text', false);
}
}
}
// Sort the group lists.
ksort($groups);
foreach ($groups as $zone => & $location)
{
sort($location);
}
// Merge any additional groups in the XML definition.
$groups = array_merge(parent::getGroups(), $groups);
return $groups;
}
}
fields/accesslevel.php 0000666 00000003103 15137260030 0011012 0 ustar 00 element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$attr .= ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
$attr .= $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$attr .= $this->multiple ? ' multiple="multiple"' : '';
// Initialize JavaScript field attributes.
$attr .= $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
// Get the field options.
$options = $this->getOptions();
return JHtml::_('access.level', $this->name, $this->value, $attr, $options, $this->id);
}
}
fields/color.php 0000666 00000003427 15137260030 0007650 0 ustar 00
*
* @package Joomla.Platform
* @subpackage Form
* @link http://www.w3.org/TR/html-markup/input.color.html
* @since 11.3
*/
class JFormFieldColor extends JFormField
{
/**
* The form field type.
*
* @var string
* @since 11.3
*/
protected $type = 'Color';
/**
* Method to get the field input markup.
*
* @return string The field input markup.
*
* @since 11.3
*/
protected function getInput()
{
// Initialize some field attributes.
$size = $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$classes = (string) $this->element['class'];
$disabled = ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
if (!$disabled)
{
JHtml::_('behavior.colorpicker');
$classes .= ' input-colorpicker';
}
if (empty($this->value))
{
// A color field can't be empty, we default to black. This is the same as the HTML5 spec.
$this->value = '#000000';
}
// Initialize JavaScript field attributes.
$onchange = $this->element['onchange'] ? ' onchange="' . (string) $this->element['onchange'] . '"' : '';
$class = $classes ? ' class="' . trim($classes) . '"' : '';
return '';
}
}
fields/imagelist.php 0000666 00000002151 15137260030 0010501 0 ustar 00 element->addAttribute('filter', $filter);
// Get the field options.
return parent::getOptions();
}
}
fields/tel.php 0000666 00000001457 15137260030 0007317 0 ustar 00 element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
$maxLength = $this->element['maxlength'] ? ' maxlength="' . (int) $this->element['maxlength'] . '"' : '';
$class = $this->element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$auto = ((string) $this->element['autocomplete'] == 'off') ? ' autocomplete="off"' : '';
$readonly = ((string) $this->element['readonly'] == 'true') ? ' readonly="readonly"' : '';
$disabled = ((string) $this->element['disabled'] == 'true') ? ' disabled="disabled"' : '';
$meter = ((string) $this->element['strengthmeter'] == 'true');
$threshold = $this->element['threshold'] ? (int) $this->element['threshold'] : 66;
$script = '';
if ($meter)
{
JHtml::_('script', 'system/passwordstrength.js', true, true);
$script = '';
}
return '' . $script;
}
}
helper.php 0000666 00000017642 15137260030 0006547 0 ustar 00
* paths:
* {ENTITY_NAME}:
* - /path/1
* - /path/2
*
*
* @var array
* @since 11.1
*
*/
protected static $paths;
/**
* Static array of JForm's entity objects for re-use.
* Prototypes for all fields and rules are here.
*
* Array's structure:
*
* entities:
* {ENTITY_NAME}:
* {KEY}: {OBJECT}
*
*
* @var array
* @since 11.1
*/
protected static $entities = array();
/**
* Method to load a form field object given a type.
*
* @param string $type The field type.
* @param boolean $new Flag to toggle whether we should get a new instance of the object.
*
* @return mixed JFormField object on success, false otherwise.
*
* @since 11.1
*/
public static function loadFieldType($type, $new = true)
{
return self::loadType('field', $type, $new);
}
/**
* Method to load a form rule object given a type.
*
* @param string $type The rule type.
* @param boolean $new Flag to toggle whether we should get a new instance of the object.
*
* @return mixed JFormRule object on success, false otherwise.
*
* @since 11.1
*/
public static function loadRuleType($type, $new = true)
{
return self::loadType('rule', $type, $new);
}
/**
* Method to load a form entity object given a type.
* Each type is loaded only once and then used as a prototype for other objects of same type.
* Please, use this method only with those entities which support types (forms don't support them).
*
* @param string $entity The entity.
* @param string $type The entity type.
* @param boolean $new Flag to toggle whether we should get a new instance of the object.
*
* @return mixed Entity object on success, false otherwise.
*
* @since 11.1
*/
protected static function loadType($entity, $type, $new = true)
{
// Reference to an array with current entity's type instances
$types = &self::$entities[$entity];
// Initialize variables.
$key = md5($type);
$class = '';
// Return an entity object if it already exists and we don't need a new one.
if (isset($types[$key]) && $new === false)
{
return $types[$key];
}
if (($class = self::loadClass($entity, $type)) !== false)
{
// Instantiate a new type object.
$types[$key] = new $class;
return $types[$key];
}
else
{
return false;
}
}
/**
* Attempt to import the JFormField class file if it isn't already imported.
* You can use this method outside of JForm for loading a field for inheritance or composition.
*
* @param string $type Type of a field whose class should be loaded.
*
* @return mixed Class name on success or false otherwise.
*
* @since 11.1
*/
public static function loadFieldClass($type)
{
return self::loadClass('field', $type);
}
/**
* Attempt to import the JFormRule class file if it isn't already imported.
* You can use this method outside of JForm for loading a rule for inheritance or composition.
*
* @param string $type Type of a rule whose class should be loaded.
*
* @return mixed Class name on success or false otherwise.
*
* @since 11.1
*/
public static function loadRuleClass($type)
{
return self::loadClass('rule', $type);
}
/**
* Load a class for one of the form's entities of a particular type.
* Currently, it makes sense to use this method for the "field" and "rule" entities
* (but you can support more entities in your subclass).
*
* @param string $entity One of the form entities (field or rule).
* @param string $type Type of an entity.
*
* @return mixed Class name on success or false otherwise.
*
* @since 11.1
*/
protected static function loadClass($entity, $type)
{
if (strpos($type, '.'))
{
list($prefix, $type) = explode('.', $type);
}
else
{
$prefix = 'J';
}
$class = JString::ucfirst($prefix, '_') . 'Form' . JString::ucfirst($entity, '_') . JString::ucfirst($type, '_');
if (class_exists($class))
{
return $class;
}
// Get the field search path array.
$paths = JFormHelper::addPath($entity);
// If the type is complex, add the base type to the paths.
if ($pos = strpos($type, '_'))
{
// Add the complex type prefix to the paths.
for ($i = 0, $n = count($paths); $i < $n; $i++)
{
// Derive the new path.
$path = $paths[$i] . '/' . strtolower(substr($type, 0, $pos));
// If the path does not exist, add it.
if (!in_array($path, $paths))
{
$paths[] = $path;
}
}
// Break off the end of the complex type.
$type = substr($type, $pos + 1);
}
// Try to find the class file.
$type = strtolower($type) . '.php';
foreach ($paths as $path)
{
if ($file = JPath::find($path, $type))
{
require_once $file;
if (class_exists($class))
{
break;
}
}
}
// Check for all if the class exists.
return class_exists($class) ? $class : false;
}
/**
* Method to add a path to the list of field include paths.
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @since 11.1
*/
public static function addFieldPath($new = null)
{
return self::addPath('field', $new);
}
/**
* Method to add a path to the list of form include paths.
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @since 11.1
*/
public static function addFormPath($new = null)
{
return self::addPath('form', $new);
}
/**
* Method to add a path to the list of rule include paths.
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @since 11.1
*/
public static function addRulePath($new = null)
{
return self::addPath('rule', $new);
}
/**
* Method to add a path to the list of include paths for one of the form's entities.
* Currently supported entities: field, rule and form. You are free to support your own in a subclass.
*
* @param string $entity Form's entity name for which paths will be added.
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @since 11.1
*/
protected static function addPath($entity, $new = null)
{
// Reference to an array with paths for current entity
$paths = &self::$paths[$entity];
// Add the default entity's search path if not set.
if (empty($paths))
{
// While we support limited number of entities (form, field and rule)
// we can do this simple pluralisation:
$entity_plural = $entity . 's';
// But when someday we would want to support more entities, then we should consider adding
// an inflector class to "libraries/joomla/utilities" and use it here (or somebody can use a real inflector in his subclass).
// see also: pluralization snippet by Paul Osman in JControllerForm's constructor.
$paths[] = dirname(__FILE__) . '/' . $entity_plural;
}
// Force the new path(s) to an array.
settype($new, 'array');
// Add the new paths to the stack if not already there.
foreach ($new as $path)
{
if (!in_array($path, $paths))
{
array_unshift($paths, trim($path));
}
}
return $paths;
}
}
.htaccess 0000666 00000000177 15137260030 0006350 0 ustar 00
Order allow,deny
Deny from all
form.php 0000666 00000154720 15137260030 0006232 0 ustar 00 name = $name;
// Initialise the JRegistry data.
$this->data = new JRegistry;
// Set the options if specified.
$this->options['control'] = isset($options['control']) ? $options['control'] : false;
}
/**
* Method to bind data to the form.
*
* @param mixed $data An array or object of data to bind to the form.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function bind($data)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// The data must be an object or array.
if (!is_object($data) && !is_array($data))
{
return false;
}
// Convert the input to an array.
if (is_object($data))
{
if ($data instanceof JRegistry)
{
// Handle a JRegistry.
$data = $data->toArray();
}
elseif ($data instanceof JObject)
{
// Handle a JObject.
$data = $data->getProperties();
}
else
{
// Handle other types of objects.
$data = (array) $data;
}
}
// Process the input data.
foreach ($data as $k => $v)
{
if ($this->findField($k))
{
// If the field exists set the value.
$this->data->set($k, $v);
}
elseif (is_object($v) || JArrayHelper::isAssociative($v))
{
// If the value is an object or an associative array hand it off to the recursive bind level method.
$this->bindLevel($k, $v);
}
}
return true;
}
/**
* Method to bind data to the form for the group level.
*
* @param string $group The dot-separated form group path on which to bind the data.
* @param mixed $data An array or object of data to bind to the form for the group level.
*
* @return void
*
* @since 11.1
*/
protected function bindLevel($group, $data)
{
// Ensure the input data is an array.
settype($data, 'array');
// Process the input data.
foreach ($data as $k => $v)
{
if ($this->findField($k, $group))
{
// If the field exists set the value.
$this->data->set($group . '.' . $k, $v);
}
elseif (is_object($v) || JArrayHelper::isAssociative($v))
{
// If the value is an object or an associative array, hand it off to the recursive bind level method
$this->bindLevel($group . '.' . $k, $v);
}
}
}
/**
* Method to filter the form data.
*
* @param array $data An array of field values to filter.
* @param string $group The dot-separated form group path on which to filter the fields.
*
* @return mixed Array or false.
*
* @since 11.1
*/
public function filter($data, $group = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// Initialise variables.
$input = new JRegistry($data);
$output = new JRegistry;
// Get the fields for which to filter the data.
$fields = $this->findFieldsByGroup($group);
if (!$fields)
{
// PANIC!
return false;
}
// Filter the fields.
foreach ($fields as $field)
{
// Initialise variables.
$name = (string) $field['name'];
// Get the field groups for the element.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
// Get the field value from the data input.
if ($group)
{
// Filter the value if it exists.
if ($input->exists($group . '.' . $name))
{
$output->set($group . '.' . $name, $this->filterField($field, $input->get($group . '.' . $name, (string) $field['default'])));
}
}
else
{
// Filter the value if it exists.
if ($input->exists($name))
{
$output->set($name, $this->filterField($field, $input->get($name, (string) $field['default'])));
}
}
}
return $output->toArray();
}
/**
* Return all errors, if any.
*
* @return array Array of error messages or JException objects.
*
* @since 11.1
*/
public function getErrors()
{
return $this->errors;
}
/**
* Method to get a form field represented as a JFormField object.
*
* @param string $name The name of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
* @param mixed $value The optional value to use as the default for the field.
*
* @return mixed The JFormField object for the field or boolean false on error.
*
* @since 11.1
*/
public function getField($name, $group = null, $value = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// Attempt to find the field by name and group.
$element = $this->findField($name, $group);
// If the field element was not found return false.
if (!$element)
{
return false;
}
return $this->loadField($element, $group, $value);
}
/**
* Method to get an attribute value from a field XML element. If the attribute doesn't exist or
* is null then the optional default value will be used.
*
* @param string $name The name of the form field for which to get the attribute value.
* @param string $attribute The name of the attribute for which to get a value.
* @param mixed $default The optional default value to use if no attribute value exists.
* @param string $group The optional dot-separated form group path on which to find the field.
*
* @return mixed The attribute value for the field.
*
* @since 11.1
*/
public function getFieldAttribute($name, $attribute, $default = null, $group = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return $default;
}
// Find the form field element from the definition.
$element = $this->findField($name, $group);
// If the element exists and the attribute exists for the field return the attribute value.
if (($element instanceof SimpleXMLElement) && ((string) $element[$attribute]))
{
return (string) $element[$attribute];
}
// Otherwise return the given default value.
else
{
return $default;
}
}
/**
* Method to get an array of JFormField objects in a given fieldset by name. If no name is
* given then all fields are returned.
*
* @param string $set The optional name of the fieldset.
*
* @return array The array of JFormField objects in the fieldset.
*
* @since 11.1
*/
public function getFieldset($set = null)
{
// Initialise variables.
$fields = array();
// Get all of the field elements in the fieldset.
if ($set)
{
$elements = $this->findFieldsByFieldset($set);
}
// Get all fields.
else
{
$elements = $this->findFieldsByGroup();
}
// If no field elements were found return empty.
if (empty($elements))
{
return $fields;
}
// Build the result array from the found field elements.
foreach ($elements as $element)
{
// Get the field groups for the element.
$attrs = $element->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
// If the field is successfully loaded add it to the result array.
if ($field = $this->loadField($element, $group))
{
$fields[$field->id] = $field;
}
}
return $fields;
}
/**
* Method to get an array of fieldset objects optionally filtered over a given field group.
*
* @param string $group The dot-separated form group path on which to filter the fieldsets.
*
* @return array The array of fieldset objects.
*
* @since 11.1
*/
public function getFieldsets($group = null)
{
// Initialise variables.
$fieldsets = array();
$sets = array();
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return $fieldsets;
}
if ($group)
{
// Get the fields elements for a given group.
$elements = &$this->findGroup($group);
foreach ($elements as &$element)
{
// Get an array of elements and fieldset attributes within the fields element.
if ($tmp = $element->xpath('descendant::fieldset[@name] | descendant::field[@fieldset]/@fieldset'))
{
$sets = array_merge($sets, (array) $tmp);
}
}
}
else
{
// Get an array of elements and fieldset attributes.
$sets = $this->xml->xpath('//fieldset[@name] | //field[@fieldset]/@fieldset');
}
// If no fieldsets are found return empty.
if (empty($sets))
{
return $fieldsets;
}
// Process each found fieldset.
foreach ($sets as $set)
{
// Are we dealing with a fieldset element?
if ((string) $set['name'])
{
// Only create it if it doesn't already exist.
if (empty($fieldsets[(string) $set['name']]))
{
// Build the fieldset object.
$fieldset = (object) array('name' => '', 'label' => '', 'description' => '');
foreach ($set->attributes() as $name => $value)
{
$fieldset->$name = (string) $value;
}
// Add the fieldset object to the list.
$fieldsets[$fieldset->name] = $fieldset;
}
}
// Must be dealing with a fieldset attribute.
else
{
// Only create it if it doesn't already exist.
if (empty($fieldsets[(string) $set]))
{
// Attempt to get the fieldset element for data (throughout the entire form document).
$tmp = $this->xml->xpath('//fieldset[@name="' . (string) $set . '"]');
// If no element was found, build a very simple fieldset object.
if (empty($tmp))
{
$fieldset = (object) array('name' => (string) $set, 'label' => '', 'description' => '');
}
// Build the fieldset object from the element.
else
{
$fieldset = (object) array('name' => '', 'label' => '', 'description' => '');
foreach ($tmp[0]->attributes() as $name => $value)
{
$fieldset->$name = (string) $value;
}
}
// Add the fieldset object to the list.
$fieldsets[$fieldset->name] = $fieldset;
}
}
}
return $fieldsets;
}
/**
* Method to get the form control. This string serves as a container for all form fields. For
* example, if there is a field named 'foo' and a field named 'bar' and the form control is
* empty the fields will be rendered like: and . If
* the form control is set to 'joomla' however, the fields would be rendered like:
* and .
*
* @return string The form control string.
*
* @since 11.1
*/
public function getFormControl()
{
return (string) $this->options['control'];
}
/**
* Method to get an array of JFormField objects in a given field group by name.
*
* @param string $group The dot-separated form group path for which to get the form fields.
* @param boolean $nested True to also include fields in nested groups that are inside of the
* group for which to find fields.
*
* @return array The array of JFormField objects in the field group.
*
* @since 11.1
*/
public function getGroup($group, $nested = false)
{
// Initialise variables.
$fields = array();
// Get all of the field elements in the field group.
$elements = $this->findFieldsByGroup($group, $nested);
// If no field elements were found return empty.
if (empty($elements))
{
return $fields;
}
// Build the result array from the found field elements.
foreach ($elements as $element)
{
// Get the field groups for the element.
$attrs = $element->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
// If the field is successfully loaded add it to the result array.
if ($field = $this->loadField($element, $group))
{
$fields[$field->id] = $field;
}
}
return $fields;
}
/**
* Method to get a form field markup for the field input.
*
* @param string $name The name of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
* @param mixed $value The optional value to use as the default for the field.
*
* @return string The form field markup.
*
* @since 11.1
*/
public function getInput($name, $group = null, $value = null)
{
// Attempt to get the form field.
if ($field = $this->getField($name, $group, $value))
{
return $field->input;
}
return '';
}
/**
* Method to get the label for a field input.
*
* @param string $name The name of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
*
* @return string The form field label.
*
* @since 11.1
*/
public function getLabel($name, $group = null)
{
// Attempt to get the form field.
if ($field = $this->getField($name, $group))
{
return $field->label;
}
return '';
}
/**
* Method to get the form name.
*
* @return string The name of the form.
*
* @since 11.1
*/
public function getName()
{
return $this->name;
}
/**
* Method to get the value of a field.
*
* @param string $name The name of the field for which to get the value.
* @param string $group The optional dot-separated form group path on which to get the value.
* @param mixed $default The optional default value of the field value is empty.
*
* @return mixed The value of the field or the default value if empty.
*
* @since 11.1
*/
public function getValue($name, $group = null, $default = null)
{
// If a group is set use it.
if ($group)
{
$return = $this->data->get($group . '.' . $name, $default);
}
else
{
$return = $this->data->get($name, $default);
}
return $return;
}
/**
* Method to load the form description from an XML string or object.
*
* The replace option works per field. If a field being loaded already exists in the current
* form definition then the behavior or load will vary depending upon the replace flag. If it
* is set to true, then the existing field will be replaced in its exact location by the new
* field being loaded. If it is false, then the new field being loaded will be ignored and the
* method will move on to the next field to load.
*
* @param string $data The name of an XML string or object.
* @param string $replace Flag to toggle whether form fields should be replaced if a field
* already exists with the same group/name.
* @param string $xpath An optional xpath to search for the fields.
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function load($data, $replace = true, $xpath = false)
{
// If the data to load isn't already an XML element or string return false.
if ((!($data instanceof SimpleXMLElement)) && (!is_string($data)))
{
return false;
}
// Attempt to load the XML if a string.
if (is_string($data))
{
$data = JFactory::getXML($data, false);
// Make sure the XML loaded correctly.
if (!$data)
{
return false;
}
}
// If we have no XML definition at this point let's make sure we get one.
if (empty($this->xml))
{
// If no XPath query is set to search for fields, and we have a , set it and return.
if (!$xpath && ($data->getName() == 'form'))
{
$this->xml = $data;
// Synchronize any paths found in the load.
$this->syncPaths();
return true;
}
// Create a root element for the form.
else
{
$this->xml = new JXMLElement('');
}
}
// Get the XML elements to load.
$elements = array();
if ($xpath)
{
$elements = $data->xpath($xpath);
}
elseif ($data->getName() == 'form')
{
$elements = $data->children();
}
// If there is nothing to load return true.
if (empty($elements))
{
return true;
}
// Load the found form elements.
foreach ($elements as $element)
{
// Get an array of fields with the correct name.
$fields = $element->xpath('descendant-or-self::field');
foreach ($fields as $field)
{
// Get the group names as strings for ancestor fields elements.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
// Check to see if the field exists in the current form.
if ($current = $this->findField((string) $field['name'], implode('.', $groups)))
{
// If set to replace found fields, replace the data and remove the field so we don't add it twice.
if ($replace)
{
$olddom = dom_import_simplexml($current);
$loadeddom = dom_import_simplexml($field);
$addeddom = $olddom->ownerDocument->importNode($loadeddom);
$olddom->parentNode->replaceChild($addeddom, $olddom);
$loadeddom->parentNode->removeChild($loadeddom);
}
else
{
unset($field);
}
}
}
// Merge the new field data into the existing XML document.
self::addNode($this->xml, $element);
}
// Synchronize any paths found in the load.
$this->syncPaths();
return true;
}
/**
* Method to load the form description from an XML file.
*
* The reset option works on a group basis. If the XML file references
* groups that have already been created they will be replaced with the
* fields in the new XML file unless the $reset parameter has been set
* to false.
*
* @param string $file The filesystem path of an XML file.
* @param string $reset Flag to toggle whether form fields should be replaced if a field
* already exists with the same group/name.
* @param string $xpath An optional xpath to search for the fields.
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function loadFile($file, $reset = true, $xpath = false)
{
// Check to see if the path is an absolute path.
if (!is_file($file))
{
// Not an absolute path so let's attempt to find one using JPath.
$file = JPath::find(self::addFormPath(), strtolower($file) . '.xml');
// If unable to find the file return false.
if (!$file)
{
return false;
}
}
// Attempt to load the XML file.
$xml = JFactory::getXML($file, true);
return $this->load($xml, $reset, $xpath);
}
/**
* Method to remove a field from the form definition.
*
* @param string $name The name of the form field for which remove.
* @param string $group The optional dot-separated form group path on which to find the field.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function removeField($name, $group = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Find the form field element from the definition.
$element = $this->findField($name, $group);
// If the element exists remove it from the form definition.
if ($element instanceof SimpleXMLElement)
{
$dom = dom_import_simplexml($element);
$dom->parentNode->removeChild($dom);
}
return true;
}
/**
* Method to remove a group from the form definition.
*
* @param string $group The dot-separated form group path for the group to remove.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function removeGroup($group)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Get the fields elements for a given group.
$elements = &$this->findGroup($group);
foreach ($elements as &$element)
{
$dom = dom_import_simplexml($element);
$dom->parentNode->removeChild($dom);
}
return true;
}
/**
* Method to reset the form data store and optionally the form XML definition.
*
* @param boolean $xml True to also reset the XML form definition.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function reset($xml = false)
{
unset($this->data);
$this->data = new JRegistry;
if ($xml)
{
unset($this->xml);
$this->xml = new JXMLElement('');
}
return true;
}
/**
* Method to set a field XML element to the form definition. If the replace flag is set then
* the field will be set whether it already exists or not. If it isn't set, then the field
* will not be replaced if it already exists.
*
* @param object &$element The XML element object representation of the form field.
* @param string $group The optional dot-separated form group path on which to set the field.
* @param boolean $replace True to replace an existing field if one already exists.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function setField(&$element, $group = null, $replace = true)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Make sure the element to set is valid.
if (!($element instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Find the form field element from the definition.
$old = &$this->findField((string) $element['name'], $group);
// If an existing field is found and replace flag is false do nothing and return true.
if (!$replace && !empty($old))
{
return true;
}
// If an existing field is found and replace flag is true remove the old field.
if ($replace && !empty($old) && ($old instanceof SimpleXMLElement))
{
$dom = dom_import_simplexml($old);
$dom->parentNode->removeChild($dom);
}
// If no existing field is found find a group element and add the field as a child of it.
if ($group)
{
// Get the fields elements for a given group.
$fields = &$this->findGroup($group);
// If an appropriate fields element was found for the group, add the element.
if (isset($fields[0]) && ($fields[0] instanceof SimpleXMLElement))
{
self::addNode($fields[0], $element);
}
}
else
{
// Set the new field to the form.
self::addNode($this->xml, $element);
}
// Synchronize any paths found in the load.
$this->syncPaths();
return true;
}
/**
* Method to set an attribute value for a field XML element.
*
* @param string $name The name of the form field for which to set the attribute value.
* @param string $attribute The name of the attribute for which to set a value.
* @param mixed $value The value to set for the attribute.
* @param string $group The optional dot-separated form group path on which to find the field.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function setFieldAttribute($name, $attribute, $value, $group = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Find the form field element from the definition.
$element = $this->findField($name, $group);
// If the element doesn't exist return false.
if (!($element instanceof SimpleXMLElement))
{
return false;
}
// Otherwise set the attribute and return true.
else
{
$element[$attribute] = $value;
// Synchronize any paths found in the load.
$this->syncPaths();
return true;
}
}
/**
* Method to set some field XML elements to the form definition. If the replace flag is set then
* the fields will be set whether they already exists or not. If it isn't set, then the fields
* will not be replaced if they already exist.
*
* @param object &$elements The array of XML element object representations of the form fields.
* @param string $group The optional dot-separated form group path on which to set the fields.
* @param boolean $replace True to replace existing fields if they already exist.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function setFields(&$elements, $group = null, $replace = true)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
// Make sure the elements to set are valid.
foreach ($elements as $element)
{
if (!($element instanceof SimpleXMLElement))
{
// TODO: throw exception.
return false;
}
}
// Set the fields.
$return = true;
foreach ($elements as $element)
{
if (!$this->setField($element, $group, $replace))
{
$return = false;
}
}
// Synchronize any paths found in the load.
$this->syncPaths();
return $return;
}
/**
* Method to set the value of a field. If the field does not exist in the form then the method
* will return false.
*
* @param string $name The name of the field for which to set the value.
* @param string $group The optional dot-separated form group path on which to find the field.
* @param mixed $value The value to set for the field.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function setValue($name, $group = null, $value = null)
{
// If the field does not exist return false.
if (!$this->findField($name, $group))
{
return false;
}
// If a group is set use it.
if ($group)
{
$this->data->set($group . '.' . $name, $value);
}
else
{
$this->data->set($name, $value);
}
return true;
}
/**
* Method to validate form data.
*
* Validation warnings will be pushed into JForm::errors and should be
* retrieved with JForm::getErrors() when validate returns boolean false.
*
* @param array $data An array of field values to validate.
* @param string $group The optional dot-separated form group path on which to filter the
* fields to be validated.
*
* @return mixed True on sucess.
*
* @since 11.1
*/
public function validate($data, $group = null)
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// Initialise variables.
$return = true;
// Create an input registry object from the data to validate.
$input = new JRegistry($data);
// Get the fields for which to validate the data.
$fields = $this->findFieldsByGroup($group);
if (!$fields)
{
// PANIC!
return false;
}
// Validate the fields.
foreach ($fields as $field)
{
// Initialise variables.
$value = null;
$name = (string) $field['name'];
// Get the group names as strings for ancestor fields elements.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
// Get the value from the input data.
if ($group)
{
$value = $input->get($group . '.' . $name);
}
else
{
$value = $input->get($name);
}
// Validate the field.
$valid = $this->validateField($field, $group, $value, $input);
// Check for an error.
if ($valid instanceof Exception)
{
switch ($valid->get('level'))
{
case E_ERROR:
JError::raiseWarning(0, $valid->getMessage());
return false;
break;
default:
array_push($this->errors, $valid);
$return = false;
break;
}
}
}
return $return;
}
/**
* Method to apply an input filter to a value based on field data.
*
* @param string $element The XML element object representation of the form field.
* @param mixed $value The value to filter for the field.
*
* @return mixed The filtered value.
*
* @since 11.1
*/
protected function filterField($element, $value)
{
// Make sure there is a valid SimpleXMLElement.
if (!($element instanceof SimpleXMLElement))
{
return false;
}
// Get the field filter type.
$filter = (string) $element['filter'];
// Process the input value based on the filter.
$return = null;
switch (strtoupper($filter))
{
// Access Control Rules.
case 'RULES':
$return = array();
foreach ((array) $value as $action => $ids)
{
// Build the rules array.
$return[$action] = array();
foreach ($ids as $id => $p)
{
if ($p !== '')
{
$return[$action][$id] = ($p == '1' || $p == 'true') ? true : false;
}
}
}
break;
// Do nothing, thus leaving the return value as null.
case 'UNSET':
break;
// No Filter.
case 'RAW':
$return = $value;
break;
// Filter the input as an array of integers.
case 'INT_ARRAY':
// Make sure the input is an array.
if (is_object($value))
{
$value = get_object_vars($value);
}
$value = is_array($value) ? $value : array($value);
JArrayHelper::toInteger($value);
$return = $value;
break;
// Filter safe HTML.
case 'SAFEHTML':
$return = JFilterInput::getInstance(null, null, 1, 1)->clean($value, 'string');
break;
// Convert a date to UTC based on the server timezone offset.
case 'SERVER_UTC':
if (intval($value) > 0)
{
// Get the server timezone setting.
$offset = JFactory::getConfig()->get('offset');
// Return an SQL formatted datetime string in UTC.
$return = JFactory::getDate($value, $offset)->toSql();
}
else
{
$return = '';
}
break;
// Convert a date to UTC based on the user timezone offset.
case 'USER_UTC':
if (intval($value) > 0)
{
// Get the user timezone setting defaulting to the server timezone setting.
$offset = JFactory::getUser()->getParam('timezone', JFactory::getConfig()->get('offset'));
// Return a MySQL formatted datetime string in UTC.
$return = JFactory::getDate($value, $offset)->toSql();
}
else
{
$return = '';
}
break;
// Ensures a protocol is present in the saved field. Only use when
// the only permitted protocols requre '://'. See JFormRuleUrl for list of these.
case 'URL':
if (empty($value))
{
return false;
}
$value = JFilterInput::getInstance()->clean($value, 'html');
$value = trim($value);
// <>" are never valid in a uri see http://www.ietf.org/rfc/rfc1738.txt.
$value = str_replace(array('<', '>', '"'), '', $value);
// Check for a protocol
$protocol = parse_url($value, PHP_URL_SCHEME);
// If there is no protocol and the relative option is not specified,
// we assume that it is an external URL and prepend http://.
if (($element['type'] == 'url' && !$protocol && !$element['relative'])
|| (!$element['type'] == 'url' && !$protocol))
{
$protocol = 'http';
// If it looks like an internal link, then add the root.
if (substr($value, 0, 9) == 'index.php')
{
$value = JURI::root() . $value;
}
// Otherwise we treat it as an external link.
else
{
// Put the url back together.
$value = $protocol . '://' . $value;
}
}
// If relative URLS are allowed we assume that URLs without protocols are internal.
elseif (!$protocol && $element['relative'])
{
$host = JURI::getInstance('SERVER')->gethost();
// If it starts with the host string, just prepend the protocol.
if (substr($value, 0) == $host)
{
$value = 'http://' . $value;
}
// Otherwise prepend the root.
else
{
$value = JURI::root() . $value;
}
}
$return = $value;
break;
case 'TEL':
$value = trim($value);
// Does it match the NANP pattern?
if (preg_match('/^(?:\+?1[-. ]?)?\(?([2-9][0-8][0-9])\)?[-. ]?([2-9][0-9]{2})[-. ]?([0-9]{4})$/', $value) == 1)
{
$number = (string) preg_replace('/[^\d]/', '', $value);
if (substr($number, 0, 1) == 1)
{
$number = substr($number, 1);
}
if (substr($number, 0, 2) == '+1')
{
$number = substr($number, 2);
}
$result = '1.' . $number;
}
// If not, does it match ITU-T?
elseif (preg_match('/^\+(?:[0-9] ?){6,14}[0-9]$/', $value) == 1)
{
$countrycode = substr($value, 0, strpos($value, ' '));
$countrycode = (string) preg_replace('/[^\d]/', '', $countrycode);
$number = strstr($value, ' ');
$number = (string) preg_replace('/[^\d]/', '', $number);
$result = $countrycode . '.' . $number;
}
// If not, does it match EPP?
elseif (preg_match('/^\+[0-9]{1,3}\.[0-9]{4,14}(?:x.+)?$/', $value) == 1)
{
if (strstr($value, 'x'))
{
$xpos = strpos($value, 'x');
$value = substr($value, 0, $xpos);
}
$result = str_replace('+', '', $value);
}
// Maybe it is already ccc.nnnnnnn?
elseif (preg_match('/[0-9]{1,3}\.[0-9]{4,14}$/', $value) == 1)
{
$result = $value;
}
// If not, can we make it a string of digits?
else
{
$value = (string) preg_replace('/[^\d]/', '', $value);
if ($value != null && strlen($value) <= 15)
{
$length = strlen($value);
// if it is fewer than 13 digits assume it is a local number
if ($length <= 12)
{
$result = '.' . $value;
}
else
{
// If it has 13 or more digits let's make a country code.
$cclen = $length - 12;
$result = substr($value, 0, $cclen) . '.' . substr($value, $cclen);
}
}
// If not let's not save anything.
else
{
$result = '';
}
}
$return = $result;
break;
default:
// Check for a callback filter.
if (strpos($filter, '::') !== false && is_callable(explode('::', $filter)))
{
$return = call_user_func(explode('::', $filter), $value);
}
// Filter using a callback function if specified.
elseif (function_exists($filter))
{
$return = call_user_func($filter, $value);
}
// Filter using JFilterInput. All HTML code is filtered by default.
else
{
$return = JFilterInput::getInstance()->clean($value, $filter);
}
break;
}
return $return;
}
/**
* Method to get a form field represented as an XML element object.
*
* @param string $name The name of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
*
* @return mixed The XML element object for the field or boolean false on error.
*
* @since 11.1
*/
protected function findField($name, $group = null)
{
// Initialise variables.
$element = false;
$fields = array();
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// Let's get the appropriate field element based on the method arguments.
if ($group)
{
// Get the fields elements for a given group.
$elements = &$this->findGroup($group);
// Get all of the field elements with the correct name for the fields elements.
foreach ($elements as $element)
{
// If there are matching field elements add them to the fields array.
if ($tmp = $element->xpath('descendant::field[@name="' . $name . '"]'))
{
$fields = array_merge($fields, $tmp);
}
}
// Make sure something was found.
if (!$fields)
{
return false;
}
// Use the first correct match in the given group.
$groupNames = explode('.', $group);
foreach ($fields as &$field)
{
// Get the group names as strings for ancestor fields elements.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$names = array_map('strval', $attrs ? $attrs : array());
// If the field is in the exact group use it and break out of the loop.
if ($names == (array) $groupNames)
{
$element = &$field;
break;
}
}
}
else
{
// Get an array of fields with the correct name.
$fields = $this->xml->xpath('//field[@name="' . $name . '"]');
// Make sure something was found.
if (!$fields)
{
return false;
}
// Search through the fields for the right one.
foreach ($fields as &$field)
{
// If we find an ancestor fields element with a group name then it isn't what we want.
if ($field->xpath('ancestor::fields[@name]'))
{
continue;
}
// Found it!
else
{
$element = &$field;
break;
}
}
}
return $element;
}
/**
* Method to get an array of elements from the form XML document which are
* in a specified fieldset by name.
*
* @param string $name The name of the fieldset.
*
* @return mixed Boolean false on error or array of SimpleXMLElement objects.
*
* @since 11.1
*/
protected function &findFieldsByFieldset($name)
{
// Initialise variables.
$false = false;
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return $false;
}
/*
* Get an array of elements that are underneath a element
* with the appropriate name attribute, and also any elements with
* the appropriate fieldset attribute.
*/
$fields = $this->xml->xpath('//fieldset[@name="' . $name . '"]//field | //field[@fieldset="' . $name . '"]');
return $fields;
}
/**
* Method to get an array of elements from the form XML document which are
* in a control group by name.
*
* @param mixed $group The optional dot-separated form group path on which to find the fields.
* Null will return all fields. False will return fields not in a group.
* @param boolean $nested True to also include fields in nested groups that are inside of the
* group for which to find fields.
*
* @return mixed Boolean false on error or array of SimpleXMLElement objects.
*
* @since 11.1
*/
protected function &findFieldsByGroup($group = null, $nested = false)
{
// Initialise variables.
$false = false;
$fields = array();
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return $false;
}
// Get only fields in a specific group?
if ($group)
{
// Get the fields elements for a given group.
$elements = &$this->findGroup($group);
// Get all of the field elements for the fields elements.
foreach ($elements as $element)
{
// If there are field elements add them to the return result.
if ($tmp = $element->xpath('descendant::field'))
{
// If we also want fields in nested groups then just merge the arrays.
if ($nested)
{
$fields = array_merge($fields, $tmp);
}
// If we want to exclude nested groups then we need to check each field.
else
{
$groupNames = explode('.', $group);
foreach ($tmp as $field)
{
// Get the names of the groups that the field is in.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$names = array_map('strval', $attrs ? $attrs : array());
// If the field is in the specific group then add it to the return list.
if ($names == (array) $groupNames)
{
$fields = array_merge($fields, array($field));
}
}
}
}
}
}
elseif ($group === false)
{
// Get only field elements not in a group.
$fields = $this->xml->xpath('descendant::fields[not(@name)]/field | descendant::fields[not(@name)]/fieldset/field ');
}
else
{
// Get an array of all the elements.
$fields = $this->xml->xpath('//field');
}
return $fields;
}
/**
* Method to get a form field group represented as an XML element object.
*
* @param string $group The dot-separated form group path on which to find the group.
*
* @return mixed An array of XML element objects for the group or boolean false on error.
*
* @since 11.1
*/
protected function &findGroup($group)
{
// Initialise variables.
$false = false;
$groups = array();
$tmp = array();
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return $false;
}
// Make sure there is actually a group to find.
$group = explode('.', $group);
if (!empty($group))
{
// Get any fields elements with the correct group name.
$elements = $this->xml->xpath('//fields[@name="' . (string) $group[0] . '"]');
// Check to make sure that there are no parent groups for each element.
foreach ($elements as $element)
{
if (!$element->xpath('ancestor::fields[@name]'))
{
$tmp[] = $element;
}
}
// Iterate through the nested groups to find any matching form field groups.
for ($i = 1, $n = count($group); $i < $n; $i++)
{
// Initialise some loop variables.
$validNames = array_slice($group, 0, $i + 1);
$current = $tmp;
$tmp = array();
// Check to make sure that there are no parent groups for each element.
foreach ($current as $element)
{
// Get any fields elements with the correct group name.
$children = $element->xpath('descendant::fields[@name="' . (string) $group[$i] . '"]');
// For the found fields elements validate that they are in the correct groups.
foreach ($children as $fields)
{
// Get the group names as strings for ancestor fields elements.
$attrs = $fields->xpath('ancestor-or-self::fields[@name]/@name');
$names = array_map('strval', $attrs ? $attrs : array());
// If the group names for the fields element match the valid names at this
// level add the fields element.
if ($validNames == $names)
{
$tmp[] = $fields;
}
}
}
}
// Only include valid XML objects.
foreach ($tmp as $element)
{
if ($element instanceof SimpleXMLElement)
{
$groups[] = $element;
}
}
}
return $groups;
}
/**
* Method to load, setup and return a JFormField object based on field data.
*
* @param string $element The XML element object representation of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
* @param mixed $value The optional value to use as the default for the field.
*
* @return mixed The JFormField object for the field or boolean false on error.
*
* @since 11.1
*/
protected function loadField($element, $group = null, $value = null)
{
// Make sure there is a valid SimpleXMLElement.
if (!($element instanceof SimpleXMLElement))
{
return false;
}
// Get the field type.
$type = $element['type'] ? (string) $element['type'] : 'text';
// Load the JFormField object for the field.
$field = $this->loadFieldType($type);
// If the object could not be loaded, get a text field object.
if ($field === false)
{
$field = $this->loadFieldType('text');
}
// Get the value for the form field if not set.
// Default to the translated version of the 'default' attribute
// if 'translate_default' attribute if set to 'true' or '1'
// else the value of the 'default' attribute for the field.
if ($value === null)
{
$default = (string) $element['default'];
if (($translate = $element['translate_default']) && ((string) $translate == 'true' || (string) $translate == '1'))
{
$lang = JFactory::getLanguage();
if ($lang->hasKey($default))
{
$debug = $lang->setDebug(false);
$default = JText::_($default);
$lang->setDebug($debug);
}
else
{
$default = JText::_($default);
}
}
$value = $this->getValue((string) $element['name'], $group, $default);
}
// Setup the JFormField object.
$field->setForm($this);
if ($field->setup($element, $value, $group))
{
return $field;
}
else
{
return false;
}
}
/**
* Proxy for {@link JFormHelper::loadFieldType()}.
*
* @param string $type The field type.
* @param boolean $new Flag to toggle whether we should get a new instance of the object.
*
* @return mixed JFormField object on success, false otherwise.
*
* @since 11.1
*/
protected function loadFieldType($type, $new = true)
{
return JFormHelper::loadFieldType($type, $new);
}
/**
* Proxy for JFormHelper::loadRuleType().
*
* @param string $type The rule type.
* @param boolean $new Flag to toggle whether we should get a new instance of the object.
*
* @return mixed JFormRule object on success, false otherwise.
*
* @see JFormHelper::loadRuleType()
* @since 11.1
*/
protected function loadRuleType($type, $new = true)
{
return JFormHelper::loadRuleType($type, $new);
}
/**
* Method to synchronize any field, form or rule paths contained in the XML document.
*
* @return boolean True on success.
*
* @since 11.1
* @todo Maybe we should receive all addXXXpaths attributes at once?
*/
protected function syncPaths()
{
// Make sure there is a valid JForm XML document.
if (!($this->xml instanceof SimpleXMLElement))
{
return false;
}
// Get any addfieldpath attributes from the form definition.
$paths = $this->xml->xpath('//*[@addfieldpath]/@addfieldpath');
$paths = array_map('strval', $paths ? $paths : array());
// Add the field paths.
foreach ($paths as $path)
{
$path = JPATH_ROOT . '/' . ltrim($path, '/\\');
self::addFieldPath($path);
}
// Get any addformpath attributes from the form definition.
$paths = $this->xml->xpath('//*[@addformpath]/@addformpath');
$paths = array_map('strval', $paths ? $paths : array());
// Add the form paths.
foreach ($paths as $path)
{
$path = JPATH_ROOT . '/' . ltrim($path, '/\\');
self::addFormPath($path);
}
// Get any addrulepath attributes from the form definition.
$paths = $this->xml->xpath('//*[@addrulepath]/@addrulepath');
$paths = array_map('strval', $paths ? $paths : array());
// Add the rule paths.
foreach ($paths as $path)
{
$path = JPATH_ROOT . '/' . ltrim($path, '/\\');
self::addRulePath($path);
}
return true;
}
/**
* Method to validate a JFormField object based on field data.
*
* @param string $element The XML element object representation of the form field.
* @param string $group The optional dot-separated form group path on which to find the field.
* @param mixed $value The optional value to use as the default for the field.
* @param object $input An optional JRegistry object with the entire data set to validate
* against the entire form.
*
* @return mixed Boolean true if field value is valid, JException on failure.
*
* @since 11.1
*/
protected function validateField($element, $group = null, $value = null, $input = null)
{
// Make sure there is a valid SimpleXMLElement.
if (!$element instanceof SimpleXMLElement)
{
return new JException(JText::_('JLIB_FORM_ERROR_VALIDATE_FIELD'), -1, E_ERROR);
}
// Initialise variables.
$valid = true;
// Check if the field is required.
$required = ((string) $element['required'] == 'true' || (string) $element['required'] == 'required');
if ($required)
{
// If the field is required and the value is empty return an error message.
if (($value === '') || ($value === null))
{
// Does the field have a defined error message?
if ($element['message'])
{
$message = $element['message'];
}
else
{
if ($element['label'])
{
$message = JText::_($element['label']);
}
else
{
$message = JText::_($element['name']);
}
$message = JText::sprintf('JLIB_FORM_VALIDATE_FIELD_REQUIRED', $message);
}
return new JException($message, 2, E_WARNING);
}
}
// Get the field validation rule.
if ($type = (string) $element['validate'])
{
// Load the JFormRule object for the field.
$rule = $this->loadRuleType($type);
// If the object could not be loaded return an error message.
if ($rule === false)
{
return new JException(JText::sprintf('JLIB_FORM_VALIDATE_FIELD_RULE_MISSING', $type), -2, E_ERROR);
}
// Run the field validation rule test.
$valid = $rule->test($element, $value, $group, $input, $this);
// Check for an error in the validation test.
if ($valid instanceof Exception)
{
return $valid;
}
}
// Check if the field is valid.
if ($valid === false)
{
// Does the field have a defined error message?
$message = (string) $element['message'];
if ($message)
{
return new JException(JText::_($message), 1, E_WARNING);
}
else
{
return new JException(JText::sprintf('JLIB_FORM_VALIDATE_FIELD_INVALID', JText::_((string) $element['label'])), 1, E_WARNING);
}
}
return true;
}
/**
* Proxy for {@link JFormHelper::addFieldPath()}.
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @since 11.1
*/
public static function addFieldPath($new = null)
{
return JFormHelper::addFieldPath($new);
}
/**
* Proxy for JFormHelper::addFormPath().
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @see JFormHelper::addFormPath()
* @since 11.1
*/
public static function addFormPath($new = null)
{
return JFormHelper::addFormPath($new);
}
/**
* Proxy for JFormHelper::addRulePath().
*
* @param mixed $new A path or array of paths to add.
*
* @return array The list of paths that have been added.
*
* @see JFormHelper::addRulePath()
* @since 11.1
*/
public static function addRulePath($new = null)
{
return JFormHelper::addRulePath($new);
}
/**
* Method to get an instance of a form.
*
* @param string $name The name of the form.
* @param string $data The name of an XML file or string to load as the form definition.
* @param array $options An array of form options.
* @param string $replace Flag to toggle whether form fields should be replaced if a field
* already exists with the same group/name.
* @param string $xpath An optional xpath to search for the fields.
*
* @return object JForm instance.
*
* @since 11.1
* @throws Exception if an error occurs.
*/
public static function getInstance($name, $data = null, $options = array(), $replace = true, $xpath = false)
{
// Reference to array with form instances
$forms = &self::$forms;
// Only instantiate the form if it does not already exist.
if (!isset($forms[$name]))
{
$data = trim($data);
if (empty($data))
{
throw new Exception(JText::_('JLIB_FORM_ERROR_NO_DATA'));
}
// Instantiate the form.
$forms[$name] = new JForm($name, $options);
// Load the data.
if (substr(trim($data), 0, 1) == '<')
{
if ($forms[$name]->load($data, $replace, $xpath) == false)
{
throw new Exception(JText::_('JLIB_FORM_ERROR_XML_FILE_DID_NOT_LOAD'));
return false;
}
}
else
{
if ($forms[$name]->loadFile($data, $replace, $xpath) == false)
{
throw new Exception(JText::_('JLIB_FORM_ERROR_XML_FILE_DID_NOT_LOAD'));
return false;
}
}
}
return $forms[$name];
}
/**
* Adds a new child SimpleXMLElement node to the source.
*
* @param SimpleXMLElement $source The source element on which to append.
* @param SimpleXMLElement $new The new element to append.
*
* @return void
*
* @since 11.1
* @throws Exception if an error occurs.
*/
protected static function addNode(SimpleXMLElement $source, SimpleXMLElement $new)
{
// Add the new child node.
$node = $source->addChild($new->getName(), trim($new));
// Add the attributes of the child node.
foreach ($new->attributes() as $name => $value)
{
$node->addAttribute($name, $value);
}
// Add any children of the new node.
foreach ($new->children() as $child)
{
self::addNode($node, $child);
}
}
/**
* Adds a new child SimpleXMLElement node to the source.
*
* @param SimpleXMLElement $source The source element on which to append.
* @param SimpleXMLElement $new The new element to append.
*
* @return void
*
* @since 11.1
*/
protected static function mergeNode(SimpleXMLElement $source, SimpleXMLElement $new)
{
// Update the attributes of the child node.
foreach ($new->attributes() as $name => $value)
{
if (isset($source[$name]))
{
$source[$name] = (string) $value;
}
else
{
$source->addAttribute($name, $value);
}
}
// What to do with child elements?
}
/**
* Merges new elements into a source element.
*
* @param SimpleXMLElement $source The source element.
* @param SimpleXMLElement $new The new element to merge.
*
* @return void
*
* @since 11.1
*/
protected static function mergeNodes(SimpleXMLElement $source, SimpleXMLElement $new)
{
// The assumption is that the inputs are at the same relative level.
// So we just have to scan the children and deal with them.
// Update the attributes of the child node.
foreach ($new->attributes() as $name => $value)
{
if (isset($source[$name]))
{
$source[$name] = (string) $value;
}
else
{
$source->addAttribute($name, $value);
}
}
foreach ($new->children() as $child)
{
$type = $child->getName();
$name = $child['name'];
// Does this node exist?
$fields = $source->xpath($type . '[@name="' . $name . '"]');
if (empty($fields))
{
// This node does not exist, so add it.
self::addNode($source, $child);
}
else
{
// This node does exist.
switch ($type)
{
case 'field':
self::mergeNode($fields[0], $child);
break;
default:
self::mergeNodes($fields[0], $child);
break;
}
}
}
}
}
rules/equals.php 0000666 00000004252 15137260030 0007705 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param JRegistry &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// Initialize variables.
$field = (string) $element['field'];
// Check that a validation field is set.
if (!$field)
{
return new JException(JText::sprintf('JLIB_FORM_INVALID_FORM_RULE', get_class($this)));
}
// Check that a valid JForm object is given for retrieving the validation field value.
if (!($form instanceof JForm))
{
return new JException(JText::sprintf('JLIB_FORM_INVALID_FORM_OBJECT', get_class($this)));
}
// Test the two values against each other.
if ($value == $input->get($field))
{
return true;
}
return false;
}
}
rules/rules.php 0000666 00000006656 15137260030 0007557 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param object &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// Get the possible field actions and the ones posted to validate them.
$fieldActions = self::getFieldActions($element);
$valueActions = self::getValueActions($value);
// Make sure that all posted actions are in the list of possible actions for the field.
foreach ($valueActions as $action)
{
if (!in_array($action, $fieldActions))
{
return false;
}
}
return true;
}
/**
* Method to get the list of permission action names from the form field value.
*
* @param mixed $value The form field value to validate.
*
* @return array A list of permission action names from the form field value.
*
* @since 11.1
*/
protected function getValueActions($value)
{
// Initialise variables.
$actions = array();
// Iterate over the asset actions and add to the actions.
foreach ((array) $value as $name => $rules)
{
$actions[] = $name;
}
return $actions;
}
/**
* Method to get the list of possible permission action names for the form field.
*
* @param object $element The SimpleXMLElement object representing the tag for the
* form field object.
*
* @return array A list of permission action names from the form field element definition.
*
* @since 11.1
*/
protected function getFieldActions($element)
{
// Initialise variables.
$actions = array();
// Initialise some field attributes.
$section = $element['section'] ? (string) $element['section'] : '';
$component = $element['component'] ? (string) $element['component'] : '';
// Get the asset actions for the element.
$elActions = JAccess::getActions($component, $section);
// Iterate over the asset actions and add to the actions.
foreach ($elActions as $item)
{
$actions[] = $item->name;
}
// Iterate over the children and add to the actions.
foreach ($element->children() as $el)
{
if ($el->getName() == 'action')
{
$actions[] = (string) $el['name'];
}
}
return $actions;
}
}
rules/tel.php 0000666 00000006101 15137260030 0007172 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param object &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// If the field is empty and not required, the field is valid.
$required = ((string) $element['required'] == 'true' || (string) $element['required'] == 'required');
if (!$required && empty($value))
{
return true;
}
// @see http://www.nanpa.com/
// @see http://tools.ietf.org/html/rfc4933
// @see http://www.itu.int/rec/T-REC-E.164/en
// Regex by Steve Levithan
// @see http://blog.stevenlevithan.com/archives/validate-phone-number
// @note that valid ITU-T and EPP must begin with +.
$regexarray = array('NANP' => '/^(?:\+?1[-. ]?)?\(?([2-9][0-8][0-9])\)?[-. ]?([2-9][0-9]{2})[-. ]?([0-9]{4})$/',
'ITU-T' => '/^\+(?:[0-9] ?){6,14}[0-9]$/', 'EPP' => '/^\+[0-9]{1,3}\.[0-9]{4,14}(?:x.+)?$/');
if (isset($element['plan']))
{
$plan = (string) $element['plan'];
if ($plan == 'northamerica' || $plan == 'us')
{
$plan = 'NANP';
}
elseif ($plan == 'International' || $plan == 'int' || $plan == 'missdn' || !$plan)
{
$plan = 'ITU-T';
}
elseif ($plan == 'IETF')
{
$plan = 'EPP';
}
$regex = $regexarray[$plan];
// Test the value against the regular expression.
if (preg_match($regex, $value) == false)
{
return false;
}
}
else
{
//If the rule is set but no plan is selected just check that there are between
//7 and 15 digits inclusive and no illegal characters (but common number separators
//are allowed).
$cleanvalue = preg_replace('/[+. \-(\)]/', '', $value);
$regex = '/^[0-9]{7,15}?$/';
if (preg_match($regex, $cleanvalue) == true)
{
return true;
}
else
{
return false;
}
}
return true;
}
}
rules/boolean.php 0000666 00000001371 15137260030 0010031 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param JRegistry &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// If the field is empty and not required, the field is valid.
$required = ((string) $element['required'] == 'true' || (string) $element['required'] == 'required');
if (!$required && empty($value))
{
return true;
}
// Test the value against the regular expression.
if (!parent::test($element, $value, $group, $input, $form))
{
return false;
}
// Check if we should test for uniqueness.
$unique = ((string) $element['unique'] == 'true' || (string) $element['unique'] == 'unique');
if ($unique)
{
// Get the database object and a new query object.
$db = JFactory::getDBO();
$query = $db->getQuery(true);
// Build the query.
$query->select('COUNT(*)');
$query->from('#__users');
$query->where('email = ' . $db->quote($value));
// Get the extra field check attribute.
$userId = ($form instanceof JForm) ? $form->getValue('id') : '';
$query->where($db->quoteName('id') . ' <> ' . (int) $userId);
// Set and query the database.
$db->setQuery($query);
$duplicate = (bool) $db->loadResult();
// Check for a database error.
if ($db->getErrorNum())
{
JError::raiseWarning(500, $db->getErrorMsg());
}
if ($duplicate)
{
return false;
}
}
return true;
}
}
rules/options.php 0000666 00000003355 15137260030 0010111 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param JRegistry &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// Check each value and return true if we get a match
foreach ($element->option as $option)
{
if ($value == (string) $option->attributes()->value)
{
return true;
}
}
return false;
}
}
rules/.htaccess 0000666 00000000177 15137260030 0007502 0 ustar 00
Order allow,deny
Deny from all
rules/username.php 0000666 00000004241 15137260030 0010230 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param JRegistry &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// Get the database object and a new query object.
$db = JFactory::getDBO();
$query = $db->getQuery(true);
// Build the query.
$query->select('COUNT(*)');
$query->from('#__users');
$query->where('username = ' . $db->quote($value));
// Get the extra field check attribute.
$userId = ($form instanceof JForm) ? $form->getValue('id') : '';
$query->where($db->quoteName('id') . ' <> ' . (int) $userId);
// Set and query the database.
$db->setQuery($query);
$duplicate = (bool) $db->loadResult();
// Check for a database error.
if ($db->getErrorNum())
{
JError::raiseWarning(500, $db->getErrorMsg());
}
if ($duplicate)
{
return false;
}
return true;
}
}
rules/color.php 0000666 00000004021 15137260030 0007523 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param object &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.2
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
$value = trim($value);
if (empty($value))
{
// A color field can't be empty, we default to black. This is the same as the HTML5 spec.
$value = '#000000';
return true;
}
if ($value[0] != '#')
{
return false;
}
// Remove the leading # if present to validate the numeric part
$value = ltrim($value, '#');
// The value must be 6 or 3 characters long
if (!((strlen($value) == 6 || strlen($value) == 3) && ctype_xdigit($value)))
{
return false;
}
// Prepend the # again
$value = '#' . $value;
return true;
}
}
rules/url.php 0000666 00000006757 15137260030 0007231 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param object &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
* @link http://www.w3.org/Addressing/URL/url-spec.txt
* @see Jstring
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// If the field is empty and not required, the field is valid.
$required = ((string) $element['required'] == 'true' || (string) $element['required'] == 'required');
if (!$required && empty($value))
{
return true;
}
$urlParts = JString::parse_url($value);
// See http://www.w3.org/Addressing/URL/url-spec.txt
// Use the full list or optionally specify a list of permitted schemes.
if ($element['schemes'] == '')
{
$scheme = array('http', 'https', 'ftp', 'ftps', 'gopher', 'mailto', 'news', 'prospero', 'telnet', 'rlogin', 'tn3270', 'wais', 'url',
'mid', 'cid', 'nntp', 'tel', 'urn', 'ldap', 'file', 'fax', 'modem', 'git');
}
else
{
$scheme = explode(',', $element['schemes']);
}
// This rule is only for full URLs with schemes because parse_url does not parse
// accurately without a scheme.
// @see http://php.net/manual/en/function.parse-url.php
if (!array_key_exists('scheme', $urlParts))
{
return false;
}
$urlScheme = (string) $urlParts['scheme'];
$urlScheme = strtolower($urlScheme);
if (in_array($urlScheme, $scheme) == false)
{
return false;
}
// For some schemes here must be two slashes.
if (($urlScheme == 'http' || $urlScheme == 'https' || $urlScheme == 'ftp' || $urlScheme == 'sftp' || $urlScheme == 'gopher'
|| $urlScheme == 'wais' || $urlScheme == 'gopher' || $urlScheme == 'prospero' || $urlScheme == 'telnet' || $urlScheme == 'git')
&& ((substr($value, strlen($urlScheme), 3)) !== '://'))
{
return false;
}
// The best we can do for the rest is make sure that the strings are valid UTF-8
// and the port is an integer.
if (array_key_exists('host', $urlParts) && !JString::valid((string) $urlParts['host']))
{
return false;
}
if (array_key_exists('port', $urlParts) && !is_int((int) $urlParts['port']))
{
return false;
}
if (array_key_exists('path', $urlParts) && !JString::valid((string) $urlParts['path']))
{
return false;
}
return true;
}
}
rules/index.html 0000666 00000000037 15137260030 0007674 0 ustar 00
rule.php 0000666 00000004525 15137260030 0006233 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param object &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param object &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 11.1
* @throws JException on invalid rule.
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
// Check for a valid regex.
if (empty($this->regex))
{
throw new JException(JText::sprintf('JLIB_FORM_INVALID_FORM_RULE', get_class($this)));
}
// Add unicode property support if available.
if (JCOMPAT_UNICODE_PROPERTIES)
{
$this->modifiers = (strpos($this->modifiers, 'u') !== false) ? $this->modifiers : $this->modifiers . 'u';
}
// Test the value against the regular expression.
if (preg_match(chr(1) . $this->regex . chr(1) . $this->modifiers, $value))
{
return true;
}
return false;
}
}
rule/captcha.php 0000666 00000004136 15137263562 0007651 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
* @param JRegistry &$input An optional JRegistry object with the entire data set to validate against the entire form.
* @param JForm &$form The form object for which the field is being tested.
*
* @return boolean True if the value is valid, false otherwise.
*
* @since 2.5
*/
public function test(&$element, $value, $group = null, &$input = null, &$form = null)
{
$plugin = $element['plugin'] ? (string) $element['plugin'] : JFactory::getApplication()->getParams()->get('captcha', JFactory::getConfig()->get('captcha', 0));
$namespace = $element['namespace'] ? (string) $element['namespace'] : $form->getName();
// Use 0 for none
if ($plugin === 0 || $plugin === '0')
{
return true;
}
else
{
$captcha = JCaptcha::getInstance($plugin, array('namespace' => $namespace));
}
// Test the value.
if (!$captcha->checkAnswer($value))
{
$error = $captcha->getError();
if ($error instanceof Exception)
{
return $error;
}
else
{
return new JException($error);
}
}
return true;
}
}
rule/.htaccess 0000666 00000000177 15137263562 0007334 0 ustar 00
Order allow,deny
Deny from all
rule/index.html 0000666 00000000037 15137263562 0007526 0 ustar 00
field/user.php 0000666 00000007333 15137263562 0007342 0 ustar 00 getGroups();
$excluded = $this->getExcluded();
$link = 'index.php?option=com_users&view=users&layout=modal&tmpl=component&field=' . $this->id
. (isset($groups) ? ('&groups=' . base64_encode(json_encode($groups))) : '')
. (isset($excluded) ? ('&excluded=' . base64_encode(json_encode($excluded))) : '');
// Initialize some field attributes.
$attr = $this->element['class'] ? ' class="' . (string) $this->element['class'] . '"' : '';
$attr .= $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
// Initialize JavaScript field attributes.
$onchange = (string) $this->element['onchange'];
// Load the modal behavior script.
JHtml::_('behavior.modal', 'a.modal_' . $this->id);
// Build the script.
$script = array();
$script[] = ' function jSelectUser_' . $this->id . '(id, title) {';
$script[] = ' var old_id = document.getElementById("' . $this->id . '_id").value;';
$script[] = ' if (old_id != id) {';
$script[] = ' document.getElementById("' . $this->id . '_id").value = id;';
$script[] = ' document.getElementById("' . $this->id . '_name").value = title;';
$script[] = ' ' . $onchange;
$script[] = ' }';
$script[] = ' SqueezeBox.close();';
$script[] = ' }';
// Add the script to the document head.
JFactory::getDocument()->addScriptDeclaration(implode("\n", $script));
// Load the current username if available.
$table = JTable::getInstance('user');
if ($this->value)
{
$table->load($this->value);
}
else
{
$table->name = JText::_('JLIB_FORM_SELECT_USER');
}
// Create a dummy text field with the user name.
$html[] = '
';
// Create the real field, hidden, that stored the user id.
$html[] = '';
return implode("\n", $html);
}
/**
* Method to get the filtering groups (null means no filtering)
*
* @return mixed array of filtering groups or null.
*
* @since 1.6.0
*/
protected function getGroups()
{
return null;
}
/**
* Method to get the users to exclude from the list of users
*
* @return mixed Array of users to exclude or null to to not exclude them
*
* @since 1.6.0
*/
protected function getExcluded()
{
return null;
}
}
field/helpsite.php 0000666 00000002030 15137263562 0010166 0 ustar 00 value));
return $options;
}
}
field/index.html 0000666 00000000037 15137263562 0007642 0 ustar 00
field/captcha.php 0000666 00000005405 15137263562 0007765 0 ustar 00 tag for the form field object.
* @param mixed $value The form field value to validate.
* @param string $group The field name group control value. This acts as as an array container for the field.
* For example if the field has name="foo" and the group value is set to "bar" then the
* full field name would end up being "bar[foo]".
*
* @return boolean True on success.
*
* @since 2.5
*/
public function setup(&$element, $value, $group = null)
{
$result = parent::setup($element, $value, $group);
$plugin = $this->element['plugin'] ? (string) $this->element['plugin'] : JFactory::getApplication()->getParams()->get('captcha', JFactory::getConfig()->get('captcha'));
if ($plugin === 0 || $plugin === '0' || $plugin === '' || $plugin === null)
{
$this->hidden = true;
}
else
{
// Force field to be required. There's no reason to have a captcha if it is not required.
// Obs: Don't put required="required" in the xml file, you just need to have validate="captcha"
$this->required = true;
$class = $this->element['class'];
if (strpos($class, 'required') === false)
{
$this->element['class'] = $class . ' required';
}
}
return $result;
}
/**
* Method to get the field input.
*
* @return string The field input.
*
* @since 2.5
*/
protected function getInput()
{
$class = $this->element['class'] ? (string) $this->element['class'] : '';
$plugin = $this->element['plugin'] ? (string) $this->element['plugin'] : JFactory::getApplication()->getParams()->get('captcha', JFactory::getConfig()->get('captcha'));
$namespace = $this->element['namespace'] ? (string) $this->element['namespace'] : $this->form->getName();
// Use 0 for none
if ($plugin === 0 || $plugin === '0' || $plugin === '' || $plugin === null)
{
return '';
}
else
{
if (($captcha = JCaptcha::getInstance($plugin, array('namespace' => $namespace))) == null)
{
return '';
}
}
return $captcha->display($this->name, $this->id, $class);
}
}
field/menu.php 0000666 00000002015 15137263562 0007320 0 ustar 00
Order allow,deny
Deny from all
field/templatestyle.php 0000666 00000005311 15137263562 0011252 0 ustar 00 element['client'] ? (string) $this->element['client'] : 'site';
$client = JApplicationHelper::getClientInfo($clientName, true);
// Get the template.
$template = (string) $this->element['template'];
// Get the database object and a new query object.
$db = JFactory::getDBO();
$query = $db->getQuery(true);
// Build the query.
$query->select('s.id, s.title, e.name as name, s.template');
$query->from('#__template_styles as s');
$query->where('s.client_id = ' . (int) $client->id);
$query->order('template');
$query->order('title');
if ($template)
{
$query->where('s.template = ' . $db->quote($template));
}
$query->join('LEFT', '#__extensions as e on e.element=s.template');
$query->where('e.enabled=1');
$query->where($db->quoteName('e.type') . '=' . $db->quote('template'));
// Set the query and load the styles.
$db->setQuery($query);
$styles = $db->loadObjectList();
// Build the grouped list array.
if ($styles)
{
foreach ($styles as $style)
{
$template = $style->template;
$lang->load('tpl_' . $template . '.sys', $client->path, null, false, true)
|| $lang->load('tpl_' . $template . '.sys', $client->path . '/templates/' . $template, null, false, true);
$name = JText::_($style->name);
// Initialize the group if necessary.
if (!isset($groups[$name]))
{
$groups[$name] = array();
}
$groups[$name][] = JHtml::_('select.option', $style->id, $style->title);
}
}
// Merge any additional groups in the XML definition.
$groups = array_merge(parent::getGroups(), $groups);
return $groups;
}
}