/**
  * The event which runs when we are displaying the record list JSON view
  *
  * @param   string  $tpl  The view sub-template to use
  *
  * @return  boolean  True to allow display of the view
  */
 protected function onDisplay($tpl = null)
 {
     $document = FOFPlatform::getInstance()->getDocument();
     if ($document instanceof JDocument) {
         $document->setMimeEncoding('application/json');
     }
     // Load the model
     $model = $this->getModel();
     $items = $model->getItemList();
     $categories = $model->getCategories();
     $publicFields = array("babioonevent_event_id", "name", "organiser", "sdate", "stime", "stimeset", "edate", "etime", "etimeset", "contact", "tel", "website", "address", "ainfo", "street", "pcode", "city", "state", "country", "geo_b", "geo_l", "teaser", "text", "isfreeofcharge", "charge", "picturefile", "created", "modified", "customfield1", "customfield2", "customfield3", "customfield4", "link");
     $publicData = array();
     foreach ($items as $item) {
         $data = array();
         foreach ($publicFields as $field) {
             $data[$field] = $item->{$field};
         }
         $data['category'] = '';
         if (array_key_exists($item->catid, $categories)) {
             $data['category'] = $categories[$item->catid]->title;
         }
         if ($item->showemail == 1) {
             $data['email'] = $item->email;
         }
         $publicData[] = $data;
     }
     $json = json_encode($publicData);
     echo $json;
     return false;
 }

 protected function loadView($view)
 {
     if ('images' == $view || 'imagesList' == $view) {
         $overridePath = FOFPlatform::getInstance()->getTemplateOverridePath('com_media', true) . '/' . $view;
         require_once $overridePath . '/view.html.php';
     }
 }

 /**
  * Create objects for the options
  *
  * @return  array  The array of option objects
  */
 protected function getOptions()
 {
     $options = array();
     // Initialize some field attributes.
     $key = $this->element['key_field'] ? (string) $this->element['key_field'] : 'value';
     $value = $this->element['value_field'] ? (string) $this->element['value_field'] : (string) $this->element['name'];
     $translate = $this->element['translate'] ? (string) $this->element['translate'] : false;
     $query = (string) $this->element['query'];
     // Get the database object.
     $db = FOFPlatform::getInstance()->getDbo();
     // Set the query and get the result list.
     $db->setQuery($query);
     $items = $db->loadObjectlist();
     // Build the field options.
     if (!empty($items)) {
         foreach ($items as $item) {
             if ($translate == true) {
                 $options[] = JHtml::_('select.option', $item->{$key}, JText::_($item->{$value}));
             } else {
                 $options[] = JHtml::_('select.option', $item->{$key}, $item->{$value});
             }
         }
     }
     // Merge any additional options in the XML definition.
     $options = array_merge(parent::getOptions(), $options);
     return $options;
 }

 /**
  * Shows the configuration page for this two factor authentication method.
  *
  * @param   object   $otpConfig  The two factor auth configuration object
  * @param   integer  $user_id    The numeric user ID of the user whose form we'll display
  *
  * @return  boolean|string  False if the method is not ours, the HTML of the configuration page otherwise
  *
  * @see     UsersModelUser::getOtpConfig
  * @since   3.2
  */
 public function onUserTwofactorShowConfiguration($otpConfig, $user_id = null)
 {
     if ($otpConfig->method == $this->methodName) {
         // This method is already activated. Reuse the same Yubikey ID.
         $yubikey = $otpConfig->config['yubikey'];
     } else {
         // This methods is not activated yet. We'll need a Yubikey TOTP to setup this Yubikey.
         $yubikey = '';
     }
     // Is this a new TOTP setup? If so, we'll have to show the code validation field.
     $new_totp = $otpConfig->method != $this->methodName;
     // Start output buffering
     @ob_start();
     // Include the form.php from a template override. If none is found use the default.
     $path = FOFPlatform::getInstance()->getTemplateOverridePath('plg_twofactorauth_yubikey', true);
     JLoader::import('joomla.filesystem.file');
     if (JFile::exists($path . '/form.php')) {
         include_once $path . '/form.php';
     } else {
         include_once __DIR__ . '/tmpl/form.php';
     }
     // Stop output buffering and get the form contents
     $html = @ob_get_clean();
     // Return the form contents
     return array('method' => $this->methodName, 'form' => $html);
 }

 /**
  * Checks out the current item
  *
  * @return  boolean
  */
 public function checkout()
 {
     $table = $this->getTable($this->table);
     $status = $table->checkout(FOFPlatform::getInstance()->getUser()->id, $this->id);
     if (!$status) {
         $this->setError($table->getError());
     }
     return $status;
 }

 /**
  * Method to get a list of tags
  *
  * @return  array  The field option objects.
  *
  * @since   3.1
  */
 protected function getOptions()
 {
     $options = array();
     $published = $this->element['published'] ? $this->element['published'] : array(0, 1);
     $db = FOFPlatform::getInstance()->getDbo();
     $query = $db->getQuery(true)->select('a.id AS value, a.path, a.title AS text, a.level, a.published')->from('#__tags AS a')->join('LEFT', $db->quoteName('#__tags') . ' AS b ON a.lft > b.lft AND a.rgt < b.rgt');
     if ($this->item instanceof FOFTable) {
         $item = $this->item;
     } else {
         $item = $this->form->getModel()->getItem();
     }
     if ($item instanceof FOFTable) {
         // Fake value for selected tags
         $keyfield = $item->getKeyName();
         $content_id = $item->{$keyfield};
         $type = $item->getContentType();
         $selected_query = $db->getQuery(true);
         $selected_query->select('tag_id')->from('#__contentitem_tag_map')->where('content_item_id = ' . (int) $content_id)->where('type_alias = ' . $db->quote($type));
         $db->setQuery($selected_query);
         $this->value = $db->loadColumn();
     }
     // Ajax tag only loads assigned values
     if (!$this->isNested()) {
         // Only item assigned values
         $values = (array) $this->value;
         FOFUtilsArray::toInteger($values);
         $query->where('a.id IN (' . implode(',', $values) . ')');
     }
     // Filter language
     if (!empty($this->element['language'])) {
         $query->where('a.language = ' . $db->quote($this->element['language']));
     }
     $query->where($db->quoteName('a.alias') . ' <> ' . $db->quote('root'));
     // Filter to only load active items
     // Filter on the published state
     if (is_numeric($published)) {
         $query->where('a.published = ' . (int) $published);
     } elseif (is_array($published)) {
         FOFUtilsArray::toInteger($published);
         $query->where('a.published IN (' . implode(',', $published) . ')');
     }
     $query->group('a.id, a.title, a.level, a.lft, a.rgt, a.parent_id, a.published, a.path')->order('a.lft ASC');
     // Get the options.
     $db->setQuery($query);
     try {
         $options = $db->loadObjectList();
     } catch (RuntimeException $e) {
         return false;
     }
     // Prepare nested data
     if ($this->isNested()) {
         $this->prepareOptionsNested($options);
     } else {
         $options = JHelperTags::convertPathsToNames($options);
     }
     return $options;
 }

 /**
  * Returns a new database query class
  *
  * @param   JDatabaseDriver  $db  The DB driver which will provide us with a query object
  *
  * @return FOFQueryAbstract
  */
 public static function &getNew($db = null)
 {
     FOFPlatform::getInstance()->logDeprecated('FOFQueryAbstract is deprecated. Use JDatabaseQuery instead.');
     if (is_null($db)) {
         $ret = FOFPlatform::getInstance()->getDbo()->getQuery(true);
     } else {
         $ret = $db->getQuery(true);
     }
     return $ret;
 }

 /**
  * Create objects for the options
  *
  * @return  array  The array of option objects
  */
 protected function getOptions()
 {
     $options = array();
     // Get the field $options
     foreach ($this->element->children() as $option) {
         // Only add <option /> elements.
         if ($option->getName() != 'option') {
             continue;
         }
         // Create a new option object based on the <option /> element.
         $options[] = 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');
     }
     // Do we have a class and method source for our options?
     $source_file = empty($this->element['source_file']) ? '' : (string) $this->element['source_file'];
     $source_class = empty($this->element['source_class']) ? '' : (string) $this->element['source_class'];
     $source_method = empty($this->element['source_method']) ? '' : (string) $this->element['source_method'];
     $source_key = empty($this->element['source_key']) ? '*' : (string) $this->element['source_key'];
     $source_value = empty($this->element['source_value']) ? '*' : (string) $this->element['source_value'];
     $source_translate = empty($this->element['source_translate']) ? 'true' : (string) $this->element['source_translate'];
     $source_translate = in_array(strtolower($source_translate), array('true', 'yes', '1', 'on')) ? true : false;
     $source_format = empty($this->element['source_format']) ? '' : (string) $this->element['source_format'];
     if ($source_class && $source_method) {
         // Maybe we have to load a file?
         if (!empty($source_file)) {
             $source_file = FOFTemplateUtils::parsePath($source_file, true);
             if (FOFPlatform::getInstance()->getIntegrationObject('filesystem')->fileExists($source_file)) {
                 include_once $source_file;
             }
         }
         // Make sure the class exists
         if (class_exists($source_class, true)) {
             // ...and so does the option
             if (in_array($source_method, get_class_methods($source_class))) {
                 // Get the data from the class
                 if ($source_format == 'optionsobject') {
                     $options = array_merge($options, $source_class::$source_method());
                 } else {
                     $source_data = $source_class::$source_method();
                     // Loop through the data and prime the $options array
                     foreach ($source_data as $k => $v) {
                         $key = empty($source_key) || $source_key == '*' ? $k : $v[$source_key];
                         $value = empty($source_value) || $source_value == '*' ? $v : $v[$source_value];
                         if ($source_translate) {
                             $value = JText::_($value);
                         }
                         $options[] = JHtml::_('select.option', $key, $value, 'value', 'text');
                     }
                 }
             }
         }
     }
     reset($options);
     return $options;
 }

 /**
  * Runs before rendering the view template, echoing HTML to put before the
  * view template's generated HTML
  *
  * @return void
  */
 protected function preRender()
 {
     $view = $this->input->getCmd('view', 'cpanel');
     $task = $this->getModel()->getState('task', 'browse');
     // Don't load the toolbar on CLI
     if (!FOFPlatform::getInstance()->isCli()) {
         $toolbar = FOFToolbar::getAnInstance($this->input->getCmd('option', 'com_foobar'), $this->config);
         $toolbar->perms = $this->perms;
         $toolbar->renderToolbar($view, $task, $this->input);
     }
     $renderer = $this->getRenderer();
     $renderer->preRender($view, $task, $this->input, $this->config);
 }

 /**
  * Method to get the list of access levels
  *
  * @return  array	A list of access levels.
  *
  * @since   2.0
  */
 protected function getOptions()
 {
     $db = FOFPlatform::getInstance()->getDbo();
     $query = $db->getQuery(true);
     $query->select('a.id AS value, a.title AS text');
     $query->from('#__viewlevels AS a');
     $query->group('a.id, a.title, a.ordering');
     $query->order('a.ordering ASC');
     $query->order($query->qn('title') . ' ASC');
     // Get the options.
     $db->setQuery($query);
     $options = $db->loadObjectList();
     return $options;
 }

 /**
  * Retrieves the two factor plugin forms
  *
  * @since	1.3
  * @access	public
  * @param	string
  * @return
  */
 public static function getForm($userId = '')
 {
     FOFPlatform::getInstance()->importPlugin('twofactorauth');
     if (!$userId) {
         $otpConfig = new stdClass();
         $otpConfig->method = 'none';
         $otpConfig->config = array();
         $otpConfig->otep = array();
     } else {
         $user = FD::user($userId);
         $otpConfig = $user->getOtpConfig();
     }
     return FOFPlatform::getInstance()->runPlugins('onUserTwofactorShowConfiguration', array($otpConfig, $userId));
 }

 /**
  * The event runs after FOFModel has called FOFTable and retrieved a single
  * item from the database. It is used to apply automatic filters.
  *
  * @param   FOFModel  &$model   The model which was called
  * @param   FOFTable  &$record  The record loaded from the databae
  *
  * @return  void
  */
 public function onAfterGetItem(&$model, &$record)
 {
     if ($record instanceof FOFTable) {
         $fieldName = $record->getColumnAlias('created_by');
         // Make sure the field actually exists
         if (!in_array($fieldName, $record->getKnownFields())) {
             return;
         }
         $user_id = FOFPlatform::getInstance()->getUser()->id;
         if ($record->{$fieldName} != $user_id) {
             $record = null;
         }
     }
 }

 public function buildQuery($overrideLimits = false)
 {
     $table = $this->getTable();
     $tableName = $table->getTableName();
     $tableKey = $table->getKeyName();
     $db = $this->getDbo();
     $query = $db->getQuery(true);
     // Call the behaviors
     $this->modelDispatcher->trigger('onBeforeBuildQuery', array(&$this, &$query));
     $alias = $this->getTableAlias();
     if ($alias) {
         $alias = ' AS ' . $db->qn($alias);
     } else {
         $alias = '';
     }
     $select = $this->getTableAlias() ? $db->qn($this->getTableAlias()) . '.*' : $db->qn($tableName) . '.*';
     $query->select($select)->from($db->qn($tableName) . $alias);
     //Frontend
     if (FOFPlatform::getInstance()->isFrontend()) {
         //Enabled
         $query->where($db->qn('enabled') . " = " . $db->quote('1'));
         //Access
         $query->where($db->quoteName('access') . " IN (" . implode(',', JFactory::getUser()->getAuthorisedViewLevels()) . ")");
     }
     if (!$overrideLimits) {
         if (FOFPlatform::getInstance()->isFrontend()) {
             $order = 'ordering';
         } else {
             $order = $this->getState('filter_order', null, 'cmd');
         }
         if (!in_array($order, array_keys($table->getData()))) {
             $order = $tableKey;
         }
         $order = $db->qn($order);
         if ($alias) {
             $order = $db->qn($this->getTableAlias()) . '.' . $order;
         }
         if (FOFPlatform::getInstance()->isFrontend()) {
             $dir = 'ASC';
         } else {
             $dir = $this->getState('filter_order_Dir', 'ASC', 'cmd');
         }
         $query->order($order . ' ' . $dir);
     }
     // Call the behaviors
     $this->modelDispatcher->trigger('onAfterBuildQuery', array(&$this, &$query));
     return $query;
 }

 /**
  * The event runs after FOFModel has called FOFTable and retrieved a single
  * item from the database. It is used to apply automatic filters.
  *
  * @param   FOFModel  &$model   The model which was called
  * @param   FOFTable  &$record  The record loaded from the databae
  *
  * @return  void
  */
 public function onAfterGetItem(&$model, &$record)
 {
     if ($record instanceof FOFTable) {
         $fieldName = $record->getColumnAlias('access');
         // Make sure the field actually exists
         if (!in_array($fieldName, $record->getKnownFields())) {
             return;
         }
         // Get the user
         $user = FOFPlatform::getInstance()->getUser();
         // Filter by authorised access levels
         if (!in_array($record->{$fieldName}, $user->getAuthorisedViewLevels())) {
             $record = null;
         }
     }
 }

 /**
  * This event runs after we have built the query used to fetch a record
  * list in a model. It is used to apply automatic query filters.
  *
  * @param   FOFModel        &$model  The model which calls this event
  * @param   JDatabaseQuery  &$query  The model which calls this event
  *
  * @return  void
  */
 public function onAfterBuildQuery(&$model, &$query)
 {
     // This behavior only applies to the front-end.
     if (!FOFPlatform::getInstance()->isFrontend()) {
         return;
     }
     // Get the name of the enabled field
     $table = $model->getTable();
     $enabledField = $table->getColumnAlias('enabled');
     // Make sure the field actually exists
     if (!in_array($enabledField, $table->getKnownFields())) {
         return;
     }
     // Filter by enabled fields only
     $db = FOFPlatform::getInstance()->getDbo();
     $query->where($db->qn($enabledField) . ' = ' . $db->q(1));
 }

 /**
  * Public constructor
  *
  * @param   array  $config  The configuration array
  */
 public function __construct($config = array())
 {
     // Make sure $config is an array
     if (is_object($config)) {
         $config = (array) $config;
     } elseif (!is_array($config)) {
         $config = array();
     }
     // Get the input
     if (array_key_exists('input', $config)) {
         if ($config['input'] instanceof FOFInput) {
             $this->input = $config['input'];
         } else {
             $this->input = new FOFInput($config['input']);
         }
     } else {
         $this->input = new FOFInput();
     }
     // Set the database object
     if (array_key_exists('dbo', $config)) {
         $this->db = $config['dbo'];
     } else {
         $this->db = FOFPlatform::getInstance()->getDbo();
     }
     // Set the $name/$_name variable
     $component = $this->input->getCmd('option', 'com_foobar');
     if (array_key_exists('option', $config)) {
         $component = $config['option'];
     }
     // Figure out where the XML schema files are stored
     if (array_key_exists('dbinstaller_directory', $config)) {
         $this->xmlDirectory = $config['dbinstaller_directory'];
     } else {
         // Nothing is defined, assume the files are stored in the sql/xml directory inside the component's administrator section
         $directories = FOFPlatform::getInstance()->getComponentBaseDirs($component);
         $this->setXmlDirectory($directories['admin'] . '/sql/xml');
     }
     // Do we have a set of XML files to look for?
     if (array_key_exists('dbinstaller_files', $config)) {
         $files = $config['dbinstaller_files'];
         if (!is_array($files)) {
             $files = explode(',', $files);
         }
         $this->xmlFiles = $files;
     }
 }

 /**
  * Create and initialise the object
  *
  * @param string $option Component name, e.g. com_foobar
  * @param string $version The current component version, as reported by the component
  * @param string $date The current component release date, as reported by the component
  */
 public function __construct($option, $version, $date)
 {
     // Initialise from parameters
     $this->option = $option;
     $this->version = $version;
     $this->date = $date;
     // Retrieve the date and version from the #__extensions table
     $db = FOFPlatform::getInstance()->getDbo();
     $query = $db->getQuery(true)->select('*')->from($db->qn('#__extensions'))->where($db->qn('element') . ' = ' . $db->q($this->option))->where($db->qn('type') . ' = ' . $db->q('component'));
     $extension = $db->setQuery($query)->loadObject();
     // Check the version and date against those from #__extensions. I hate heavily nested IFs as much as the next
     // guy, but what can you do...
     if (!is_null($extension)) {
         $manifestCache = $extension->manifest_cache;
         if (!empty($manifestCache)) {
             $manifestCache = json_decode($manifestCache, true);
             if (is_array($manifestCache) && isset($manifestCache['creationDate']) && isset($manifestCache['version'])) {
                 // Make sure the fileslist.php version and date match the component's version
                 if ($this->version != $manifestCache['version']) {
                     $this->wrongComponentVersion = true;
                 }
                 if ($this->date != $manifestCache['creationDate']) {
                     $this->wrongComponentVersion = true;
                 }
             }
         }
     }
     // Try to load the fileslist.php file from the component's back-end root
     $filePath = JPATH_ADMINISTRATOR . '/components/' . $this->option . '/fileslist.php';
     if (!file_exists($filePath)) {
         return;
     }
     include $filePath;
     // Make sure the fileslist.php version and date match the component's version
     if ($this->version != $phpFileChecker['version']) {
         $this->wrongFilesVersion = true;
     }
     if ($this->date != $phpFileChecker['date']) {
         $this->wrongFilesVersion = true;
     }
     // Initialise the files and directories lists
     $this->fileList = $phpFileChecker['files'];
     $this->dirList = $phpFileChecker['directories'];
 }

 /**
  * Displays the view
  *
  * @param   string  $tpl  The template to use
  *
  * @return  boolean|null False if we can't render anything
  */
 public function display($tpl = null)
 {
     $model = $this->getModel();
     // Get the form
     $this->form = $model->getForm();
     $this->form->setModel($model);
     $this->form->setView($this);
     // Get the task set in the model
     $task = $model->getState('task', 'browse');
     // Call the relevant method
     $method_name = 'on' . ucfirst($task);
     if (method_exists($this, $method_name)) {
         $result = $this->{$method_name}($tpl);
     } else {
         $result = $this->onDisplay();
     }
     // Bail out if we're told not to render anything
     if ($result === false) {
         return;
     }
     // Show the view
     // -- Output HTML before the view template
     $this->preRender();
     // -- Try to load a view template; if not exists render the form directly
     $basePath = FOFPlatform::getInstance()->isBackend() ? 'admin:' : 'site:';
     $basePath .= $this->config['option'] . '/';
     $basePath .= $this->config['view'] . '/';
     $path = $basePath . $this->getLayout();
     if ($tpl) {
         $path .= '_' . $tpl;
     }
     $viewTemplate = $this->loadAnyTemplate($path);
     // If there was no template file found, display the form
     if ($viewTemplate instanceof Exception) {
         $viewTemplate = $this->getRenderedForm();
     }
     // -- Output the view template
     echo $viewTemplate;
     // -- Output HTML after the view template
     $this->postRender();
 }

 /**
  * Method to finds the full real file path, checking possible overrides
  *
  * @return  string  The full path to the layout file
  */
 protected function getPath()
 {
     $filesystem = FOFPlatform::getInstance()->getFilesystem();
     if (is_null($this->fullPath) && !empty($this->layoutId)) {
         $parts = explode('.', $this->layoutId);
         $file = array_pop($parts);
         $filePath = implode('/', $parts);
         $suffixes = FOFPlatform::getInstance()->getTemplateSuffixes();
         foreach ($suffixes as $suffix) {
             $files[] = $file . $suffix . '.php';
         }
         $files[] = $file . '.php';
         $possiblePaths = array(JPATH_THEMES . '/' . JFactory::getApplication()->getTemplate() . '/html/layouts/' . $filePath, $this->basePath . '/' . $filePath);
         reset($files);
         while ((list(, $fileName) = each($files)) && is_null($this->fullPath)) {
             $r = $filesystem->pathFind($possiblePaths, $fileName);
             $this->fullPath = $r === false ? null : $r;
         }
     }
     return $this->fullPath;
 }

 /**
  * Loads the component's configuration parameters so they can be accessed by getComponentConfigurationValue
  *
  * @param   string  $component  The component for loading the parameters
  * @param   bool    $force      Should I force-reload the configuration information?
  */
 public static final function loadComponentConfig($component, $force = false)
 {
     if (isset(self::$componentParams[$component]) && !is_null(self::$componentParams[$component]) && !$force) {
         return;
     }
     $db = FOFPlatform::getInstance()->getDbo();
     $sql = $db->getQuery(true)->select($db->qn('params'))->from($db->qn('#__extensions'))->where($db->qn('type') . ' = ' . $db->q('component'))->where($db->qn('element') . " = " . $db->q($component));
     $db->setQuery($sql);
     $config_ini = $db->loadResult();
     // OK, Joomla! 1.6 stores values JSON-encoded so, what do I do? Right!
     $config_ini = trim($config_ini);
     if (substr($config_ini, 0, 1) == '{' && substr($config_ini, -1) == '}') {
         $config_ini = json_decode($config_ini, true);
     } else {
         $config_ini = FOFUtilsIniParser::parse_ini_file($config_ini, false, true);
     }
     if (is_null($config_ini) || empty($config_ini)) {
         $config_ini = array();
     }
     self::$componentParams[$component] = $config_ini;
 }