/**
* Settings
*
* @access public
* @param array
* @return array
*/
public function settings()
{
// -------------------------------------------
// Get member groups with access to CP
// -------------------------------------------
$query = ee()->db->select('group_id, group_title')->from('member_groups')->where('can_access_cp', 'y')->order_by('group_title')->get();
$groups = low_flatten_results($query->result_array(), 'group_title', 'group_id');
// -------------------------------------------
// Return list of groups
// -------------------------------------------
return array('can_create_sets' => array('ms', $groups, $this->default_settings['can_create_sets']));
}
/**
* Display input field for regular user
*
* @access public
* @param int $var_id The id of the variable
* @param string $var_data The value of the variable
* @param array $var_settings The settings of the variable
* @return string
*/
function display_input($var_id, $var_data, $var_settings)
{
// Keep track of all LR Sets
static $sets;
// Get them if not existing
if (!$sets) {
$query = $this->EE->db->select('set_id, set_label')->from('low_reorder_sets')->where('site_id', $this->EE->config->item('site_id'))->order_by('set_label', 'asc')->get();
$sets = low_flatten_results($query->result_array(), 'set_label', 'set_id');
}
// Prepend empty option
$options = array('' => '--') + $sets;
// Return select element
return form_dropdown("var[{$var_id}]", $options, $var_data);
}
/**
* Allows for category groups filtering: (1|2|3) && (4|5|6)
*
* @access public
* @return void
*/
public function filter($entry_ids)
{
// --------------------------------------
// See if there are groups present, with correct values
// --------------------------------------
$groups = array_filter($this->params->get_prefixed('category:'), 'low_param_is_numeric');
// --------------------------------------
// Bail out if there are no groups
// --------------------------------------
if (empty($groups)) {
return $entry_ids;
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// --------------------------------------
// Loop through groups, compose SQL
// --------------------------------------
foreach ($groups as $key => $val) {
// Prep the value
$val = $this->params->prep($key, $val);
// Get the parameter
list($ids, $in) = low_explode_param($val);
// Match all?
$all = (bool) strpos($val, '&');
// One query per group
ee()->db->select('entry_id')->from('category_posts')->{$in ? 'where_in' : 'where_not_in'}('cat_id', $ids);
// Limit by already existing ids
if ($entry_ids) {
ee()->db->where_in('entry_id', $entry_ids);
}
// Do the having-trick to account for *all* given entry ids
if ($in && $all) {
ee()->db->select('COUNT(*) AS num')->group_by('entry_id')->having('num', count($ids));
}
// Execute query
$query = ee()->db->get();
// And get the entry ids
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
$entry_ids = array_unique($entry_ids);
// Bail out if there aren't any matches
if (is_array($entry_ids) && empty($entry_ids)) {
break;
}
}
return $entry_ids;
}
/**
* Display settings sub-form for this variable type
*
* @param mixed $var_id The id of the variable: 'new' or numeric
* @param array $var_settings The settings of the variable
* @return array
*/
function display_settings($var_id, $var_settings)
{
// -------------------------------------
// Init return value
// -------------------------------------
$r = array();
// -------------------------------------
// Check current value from settings
// -------------------------------------
$folders = $this->get_setting('folders', $var_settings);
// -------------------------------------
// Get all folders
// -------------------------------------
$all_folders = low_flatten_results($this->_get_upload_preferences(), 'name', 'id');
// -------------------------------------
// Build options setting
// -------------------------------------
$r[] = array($this->setting_label(lang('file_folders')), form_multiselect($this->input_name('folders', TRUE), $all_folders, $folders));
// -------------------------------------
// Build setting: Allow uploads?
// -------------------------------------
$upload_folders = array('0' => lang('no_uploads')) + $all_folders;
$upload = $this->get_setting('upload', $var_settings);
$overwrite = $this->get_setting('overwrite', $var_settings) == 'y';
$r[] = array($this->setting_label(lang('upload_folder'), lang('upload_folder_help')), form_dropdown($this->input_name('upload'), $upload_folders, $upload, 'id="low-select-upload-folder"') . '<label class="low-checkbox low-inline" id="low-overwrite-files">' . form_checkbox($this->input_name('overwrite'), 'y', $overwrite) . lang('overwrite_existing_files_label') . '</label>');
// -------------------------------------
// Build setting: multiple?
// -------------------------------------
$multiple = $this->get_setting('multiple', $var_settings) == 'y';
$r[] = array($this->setting_label(lang('allow_multiple_files')), '<label class="low-checkbox">' . form_checkbox($this->input_name('multiple'), 'y', $multiple, 'class="low-allow-multiple"') . lang('allow_multiple_files_label') . '</label>');
// -------------------------------------
// Build setting: separator
// -------------------------------------
$separator = $this->get_setting('separator', $var_settings);
$r[] = array($this->setting_label(lang('separator_character')), $this->separator_select($separator));
// -------------------------------------
// Build setting: multi interface
// -------------------------------------
$multi_interface = $this->get_setting('multi_interface', $var_settings);
$r[] = array($this->setting_label(lang('multi_interface')), $this->interface_select($multi_interface, array('drag-list-thumbs' => lang('drag-list-thumbs'))));
// -------------------------------------
// Return output
// -------------------------------------
return $r;
}
/**
* Update routines for version 2.0b1
*
* @access private
* @return void
*/
private function _v20b1()
{
// --------------------------------------
// Install new tables
// --------------------------------------
ee()->low_reorder_set_model->install();
ee()->low_reorder_order_model->install();
// --------------------------------------
// Get all current records from settings
// --------------------------------------
$query = ee()->db->get('low_reorder_settings');
$rows = $query->result_array();
// Return if no settings exist
if (!empty($rows)) {
// Upgrading from EE1
if (!isset($rows[0]['channel_id'])) {
foreach ($rows as &$r) {
$r['channel_id'] = $r['weblog_id'];
}
}
// --------------------------------------
// Get Field, Channel and Status details
// --------------------------------------
// Fields
$query = ee()->db->select('field_id, site_id, field_name, field_label, field_instructions')->from('channel_fields')->where_in('field_id', low_flatten_results($rows, 'field_id'))->get();
$fields = low_associate_results($query->result_array(), 'field_id');
// Channels
$query = ee()->db->select('channel_id, channel_name, channel_title, cat_group')->from('channels')->where_in('channel_id', low_flatten_results($rows, 'channel_id'))->get();
$channels = low_associate_results($query->result_array(), 'channel_id');
// Statuses
$query = ee()->db->select('status_id, status')->from('statuses')->get();
$statuses = low_flatten_results($query->result_array(), 'status', 'status_id');
// --------------------------------------
// Loop through rows and populate new table
// --------------------------------------
foreach ($rows as $row) {
// Skip non-existent channels or fields
if (!(isset($channels[$row['channel_id']]) && isset($fields[$row['field_id']]))) {
continue;
}
// Shortcut to related channel and field
$channel = $channels[$row['channel_id']];
$field = $fields[$row['field_id']];
// Decode the settings
$settings = decode_reorder_settings($row['settings']);
// Initiate parameter array
$params = array();
// --------------------------------------
// Set Channel parameter
// --------------------------------------
$params['channel'] = $channels[$row['channel_id']]['channel_name'];
// --------------------------------------
// Set Category parameter
// --------------------------------------
if (!empty($settings['categories'])) {
$params['category'] = implode('|', array_filter($settings['categories']));
}
// --------------------------------------
// Set Status parameter
// --------------------------------------
if (!empty($settings['statuses'])) {
$tmp = array();
foreach ($settings['statuses'] as $status_id) {
$tmp[] = $statuses[$status_id];
}
$params['status'] = implode('|', array_unique($tmp));
unset($tmp);
}
// --------------------------------------
// Set Show Expired parameter
// --------------------------------------
if (!empty($settings['show_expired']) && ($settings['show_expired'] == 'y' or $settings['show_expired'] === TRUE)) {
$params['show_expired'] = 'yes';
}
// --------------------------------------
// Set Show Future Entries parameter
// --------------------------------------
if (!empty($settings['show_future']) && ($settings['show_future'] == 'y' or $settings['show_future'] === TRUE)) {
$params['show_future_entries'] = 'yes';
}
// --------------------------------------
// Get permissions from settings
// --------------------------------------
$permissions = !empty($settings['permissions']) ? low_array_encode($settings['permissions']) : '';
// --------------------------------------
// Set Category Option value
// --------------------------------------
$cat_option = $settings['category_options'];
// --------------------------------------
// Set Category Groups value, if option is 'one'
// --------------------------------------
if ($cat_option == 'one' && $channel['cat_group']) {
$cat_groups = low_linearize(explode('|', $channel['cat_group']));
} else {
$cat_groups = '';
}
// --------------------------------------
// Set clear_cache value
// --------------------------------------
$clear_cache = !empty($settings['clear_cache']) && $settings['clear_cache'] == 'n' ? 'n' : 'y';
// --------------------------------------
// Sort order setting
// --------------------------------------
$reverse = @$settings['sort_order'] == 'desc';
// --------------------------------------
// Insert new row
// --------------------------------------
$set_id = ee()->low_reorder_set_model->insert(array('site_id' => $field['site_id'], 'set_label' => $channel['channel_title'] . ', ' . $field['field_label'], 'set_notes' => $field['field_instructions'], 'new_entries' => $reverse ? 'prepend' : 'append', 'clear_cache' => $clear_cache, 'channels' => low_linearize(array($row['channel_id'])), 'cat_option' => $cat_option, 'cat_groups' => $cat_groups, 'parameters' => low_array_encode($params), 'permissions' => $permissions));
// --------------------------------------
// Get current values
// --------------------------------------
ee()->db->select("GROUP_CONCAT(DISTINCT d.entry_id ORDER BY d.field_id_{$field['field_id']} ASC SEPARATOR '|') AS entries", FALSE)->from('channel_data d')->where('d.channel_id', $channel['channel_id'])->where("d.field_id_{$field['field_id']} !=", '');
if ($cat_option != 'one') {
ee()->db->select("'0' AS cat_id", FALSE);
} else {
ee()->db->select('cp.cat_id')->from('category_posts cp')->where('d.entry_id = cp.entry_id')->group_by('cat_id');
}
$query = ee()->db->get();
foreach ($query->result() as $row) {
$entries = low_delinearize($row->entries);
if ($reverse) {
$entries = array_reverse($entries);
}
ee()->low_reorder_order_model->insert(array('set_id' => $set_id, 'cat_id' => $row->cat_id, 'sort_order' => low_linearize($entries)));
}
}
}
// end if $rows
// --------------------------------------
// Change low_reorder fieldtype to text
// --------------------------------------
ee()->db->where('field_type', $this->package);
ee()->db->update('channel_fields', array('field_type' => 'text', 'field_settings' => low_array_encode(array('field_content_type' => 'text'))));
// --------------------------------------
// Remove low_reorder fieldtype
// --------------------------------------
ee()->db->where('name', $this->package);
ee()->db->delete('fieldtypes');
// --------------------------------------
// Drop old table
// --------------------------------------
ee()->db->query("DROP TABLE IF EXISTS `exp_low_reorder_settings`");
// --------------------------------------
// Enable extension
// --------------------------------------
foreach ($this->hooks as $hook) {
$this->_add_hook($hook);
}
}
/**
* Display input field for regular user
*
* @param int $var_id The id of the variable
* @param string $var_data The value of the variable
* @param array $var_settings The settings of the variable
* @return string
*/
public function display_input($var_id, $var_data, $var_settings)
{
// -------------------------------------
// Prep options
// -------------------------------------
$settings = array();
foreach ($this->default_settings as $key => $val) {
$settings[$key] = $this->get_setting($key, $var_settings);
}
// -------------------------------------
// Prep current data
// -------------------------------------
$current = explode($this->separators[$settings['separator']], $var_data);
$now = ee()->localize->now;
// -------------------------------------
// Get entries
// -------------------------------------
ee()->db->select(array('t.entry_id', 't.title'))->from('channel_titles AS t');
// Filter out future entries
if ($settings['show_future'] != 'y') {
ee()->db->where('t.entry_date <=', $now);
}
// Filter out expired entries
if ($settings['show_expired'] != 'y') {
ee()->db->where("(t.expiration_date > {$now} OR t.expiration_date = 0)");
}
// Filter by channel
if ($filtered_channels = array_filter((array) $settings['channels'])) {
ee()->db->where_in('t.channel_id', $filtered_channels);
}
// Filter by category
if ($filtered_categories = array_filter((array) $settings['categories'])) {
ee()->db->join('category_posts AS cp', 't.entry_id = cp.entry_id');
ee()->db->where_in('cp.cat_id', $filtered_categories);
}
// Filter by status
if ($filtered_statuses = array_filter((array) $settings['statuses'])) {
ee()->db->where_in('t.status', $filtered_statuses);
}
// Order by custom order
ee()->db->order_by($settings['orderby'], $settings['sort']);
// Limit entries
if ($settings['limit']) {
ee()->db->limit($settings['limit']);
}
$query = ee()->db->get();
$entries = low_flatten_results($query->result_array(), 'title', 'entry_id');
// -------------------------------------
// Create interface
// -------------------------------------
if ($settings['multiple'] == 'y' && $settings['multi_interface'] == 'drag-list') {
$r = $this->drag_lists($var_id, $entries, $current);
} else {
$r = $this->select_element($var_id, $entries, $current, $settings['multiple'] == 'y');
}
// -------------------------------------
// Return select element
// -------------------------------------
return $r;
}
/**
* Allows for tag filtering: (1|2|3) && (4|5|6)
*
* @access public
* @return void
*/
public function filter($entry_ids)
{
// -------------------------------------------
// Make sure addons-library is loaded
// -------------------------------------------
ee()->load->library('addons');
// -------------------------------------------
// Solspace Tag or DevDemon Tagger?
// -------------------------------------------
if (ee()->addons->is_package('tag')) {
$tables = array('tag_tags', 'tag_entries');
} elseif (ee()->addons->is_package('tagger')) {
$tables = array('tagger', 'tagger_links');
}
// --------------------------------------
// See if there are tag params present
// --------------------------------------
$tag_names = $this->params->get_prefixed('tag_name');
$tag_ids = $this->params->get_prefixed('tag_id');
// --------------------------------------
// Bail out if there are no tags
// --------------------------------------
if (empty($tables) || empty($tag_names) && empty($tag_ids)) {
return $entry_ids;
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// -------------------------------------------
// Check tag names and convert to tag IDs
// -------------------------------------------
if ($tag_names) {
$unique_tags = array();
foreach ($tag_names as $key => $val) {
// Get the tags
list($tags, $in) = low_explode_param($val);
$unique_tags = array_merge($unique_tags, $tags);
}
// Remove duplicates and convert
$unique_tags = array_unique($unique_tags);
$unique_tags = array_map(array($this, '_convert_tag'), $unique_tags);
// Get IDs for unique tags
$query = ee()->db->select('tag_id, tag_name')->from($tables[0])->where_in('site_id', $this->params->site_ids())->where_in('tag_name', $unique_tags)->get();
// clean up
unset($unique_tags);
// Get tag map: [tag name] => tag_id
$tag_map = low_flatten_results($query->result_array(), 'tag_id', 'tag_name');
// Now, loop through original tags thing and convert to tag IDs
foreach ($tag_names as $key => $val) {
// Initiate tag ids
$ids = array();
// Read parameter value
list($tags, $in) = low_explode_param($val);
// Loop through tags and map them to IDs
foreach ($tags as $tag) {
$tag = $this->_convert_tag($tag);
if (isset($tag_map[$tag])) {
$ids[] = $tag_map[$tag];
}
}
if ($ids) {
// Check separator and implode back to parameter
$sep = strpos($val, '&') === FALSE ? '|' : '&';
$str = implode($sep, $ids);
// Add negator back
if (!$in) {
$str = 'not ' . $ids;
}
// Add final parameter string to IDs
$tag_ids[$key] = $str;
}
}
}
// --------------------------------------
// Get channel IDs before starting the query
// --------------------------------------
$channel_ids = ee()->low_search_collection_model->get_channel_ids($this->params->get('collection'));
// --------------------------------------
// Loop through groups, compose SQL
// --------------------------------------
foreach ($tag_ids as $key => $val) {
// Prep the value
$val = $this->params->prep($key, $val);
// Get the parameter
list($ids, $in) = low_explode_param($val);
// Match all?
$all = (bool) strpos($val, '&');
// One query per group
ee()->db->distinct()->select('entry_id')->from($tables[1])->where_in('site_id', $this->params->site_ids())->{$in ? 'where_in' : 'where_not_in'}('tag_id', $ids);
// Limit by already existing ids
if ($entry_ids) {
ee()->db->where_in('entry_id', $entry_ids);
}
// Limit by channel ID
if ($channel_ids) {
ee()->db->where_in('channel_id', $channel_ids);
}
// Do the having-trick to account for *all* given entry ids
if ($in && $all) {
ee()->db->select('COUNT(*) AS num')->group_by('entry_id')->having('num', count($ids));
}
// Execute query
$query = ee()->db->get();
// And get the entry ids
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
// Bail out if there aren't any matches
if (is_array($entry_ids) && empty($entry_ids)) {
break;
}
}
return $entry_ids;
}
/**
* Get oldest index for given collection or all collections
*
* @access public
* @param int
* @param array
* @return void
*/
public function get_oldest_index($collection_id = FALSE)
{
ee()->db->select('collection_id, MIN(index_date) AS index_date')->from($this->table())->where('site_id', $this->site_id)->group_by('collection_id');
// Limit by given collection
if ($collection_id) {
ee()->db->where('collection_id', $collection_id);
}
$query = ee()->db->get();
// Return array of collection_id => index_date
return low_flatten_results($query->result_array(), 'index_date', 'collection_id');
}
/**
* Modify a row for a search result for this filter
*/
public function results($rows)
{
// -------------------------------------------
// Shortcut to prefix
// -------------------------------------------
$pfx = ee()->low_search_settings->prefix;
// -------------------------------------------
// Prep collection info
// -------------------------------------------
if (!$this->_collections && $this->_results) {
$col_ids = low_flatten_results($this->_results, 'collection_id');
$col_ids = array_unique($col_ids);
$this->_collections = ee()->low_search_collection_model->get_by_id($col_ids);
}
// -------------------------------------------
// Loop through results and do yer thing
// -------------------------------------------
foreach ($rows as &$row) {
// Get score for this entry
$row[$pfx . 'score'] = $this->_get_score($row['entry_id']);
// Add collection info to row
foreach ($this->_get_collection_info($row['entry_id']) as $key => $val) {
$row[$pfx . $key] = $val;
}
}
// -------------------------------------------
// No excerpt var in tagdata? No need to proceed.
// -------------------------------------------
if (strpos(ee()->TMPL->tagdata, $pfx . 'excerpt') === FALSE) {
return $rows;
}
// -------------------------------------------
// Load typography lib
// -------------------------------------------
ee()->load->library('typography');
// -------------------------------------------
// Get all entry ids we're working with
// -------------------------------------------
$entry_ids = low_flatten_results($rows, 'entry_id');
// -------------------------------------------
// Loop through results and add the excerpt
// -------------------------------------------
foreach ($rows as &$row) {
// Get excerpt ID, the field ID to use as excerpt; 0 for title
$eid = $this->_get_excerpt_id($row);
// Skip if no valid excerpt ID is found
if ($eid === FALSE) {
continue;
}
// Get string and format for excerpt
$str = $eid == '0' || !isset($row['field_id_' . $eid]) ? $row['title'] : $row['field_id_' . $eid];
$fmt = $eid == '0' || !isset($row['field_fmt_' . $eid]) ? 'xhtml' : $row['field_fmt_' . $eid];
// -------------------------------------------
// 'low_search_excerpt' hook
// - change the excerpt for an entry
// -------------------------------------------
if (ee()->extensions->active_hook('low_search_excerpt') === TRUE) {
$str = ee()->extensions->call('low_search_excerpt', $entry_ids, $row, $eid);
// Check return value
if (is_array($str) && count($str) == 2) {
// Set excerpt string to first item in array
list($str, $skip) = $str;
// If second item in return value, skip native creation of excerpt
if ($skip === TRUE) {
$row[$pfx . 'excerpt'] = $str;
continue;
}
}
}
// Overwrite empty excerpt with formatted one
$row[$pfx . 'excerpt'] = $this->_create_excerpt($str, $fmt);
// Highlight keywords if we have 'em
if ($this->_keywords) {
$row[$pfx . 'excerpt'] = $this->_highlight($row[$pfx . 'excerpt']);
if (ee()->low_search_settings->get('title_hilite') == 'y') {
$row['title'] = $this->_highlight($row['title']);
}
}
}
return $rows;
}
/**
* Filter the set's entry ids according to parameters
*
* @access private
* @return void
*/
private function _filter_entry_ids()
{
// Set/Cat key
$key = $this->set_id . '-' . $this->cat_id;
// Get entries from cache
$entries = array_filter((array) low_get_cache(LOW_REORDER_PACKAGE, 'entry_ids'));
if (!isset($entries[$key])) {
// Log to template
$this->_log('Getting ordered entry_ids from database');
// Add channel_id and entry_id as parameter
$params = $this->set['parameters'];
$params['channel_id'] = implode('|', $this->set['channels']);
$params['entry_id'] = implode('|', $this->entry_ids);
// Fetch from DB
$filtered = low_flatten_results($this->get_entries($params, FALSE), 'entry_id');
// Intersect to preserve the order
$filtered = array_filter(array_intersect($this->entry_ids, $filtered));
$filtered = array_values($filtered);
// Add to cache
$entries[$key] = $filtered;
low_set_cache(LOW_REORDER_PACKAGE, 'entry_ids', $entries);
// Clean up
unset($filtered);
} else {
// Log to template
$this->_log('Getting ordered entry_ids from cache');
}
// Set the working entry ids to the filtered ones
$this->entry_ids = $entries[$key];
}
/**
* Takes a DB result set, returns 'flat' array with key => val
*
* @param array $result_set array with arrays (1 per result)
* @param string $key key value for flat array
* @param string $val value value for flat array
* @return array
*/
protected function flatten_results($result_set, $key, $val)
{
return low_flatten_results($result_set, $val, $key);
}
/**
* Build collection index
*
* @access protected
* @return array
*/
public function build($collection_id = FALSE, $entry_ids = FALSE, $start = FALSE)
{
// --------------------------------------
// Check for collection_id or entry_id
// --------------------------------------
$collection_id = $collection_id !== FALSE ? $collection_id : ee()->input->get_post('collection_id');
$entry_ids = $entry_ids !== FALSE ? $entry_ids : ee()->input->get_post('entry_id');
// --------------------------------------
// Either collection_id or entry_id or both must be given
// --------------------------------------
if (!($collection_id || $entry_ids)) {
show_error(ee()->lang->line('not_authorized'));
}
// --------------------------------------
// Start building query to get collection details
// --------------------------------------
ee()->db->select('lsc.collection_id, lsc.channel_id, lsc.settings, lsc.site_id');
ee()->db->from('low_search_collections lsc');
// --------------------------------------
// If there's a collection id, limit query by that one
// --------------------------------------
if ($collection_id) {
ee()->db->where('lsc.collection_id', $collection_id);
}
// --------------------------------------
// If there's an entry_id, limit query by those
// --------------------------------------
if ($entry_ids) {
// Force array
if (!is_array($entry_ids)) {
$entry_ids = preg_split('/\\D+/', $entry_ids);
}
// Get collections for given entries
ee()->db->select('GROUP_CONCAT(ct.entry_id) AS entries');
ee()->db->join('channel_titles ct', 'lsc.channel_id = ct.channel_id');
ee()->db->where_in('entry_id', $entry_ids);
ee()->db->group_by('lsc.collection_id');
}
// --------------------------------------
// Execute query and get results. Bail out if none
// --------------------------------------
if (!($collections = ee()->db->get()->result_array())) {
return FALSE;
}
$collections = low_associate_results($collections, 'collection_id');
$channel_ids = array_unique(low_flatten_results($collections, 'channel_id'));
// --------------------------------------
// Get batch size
// --------------------------------------
$batch_size = ee()->low_search_settings->get('batch_size');
// --------------------------------------
// Get total number of entries that need to be indexed
// --------------------------------------
if ($entry_ids) {
$num_entries = count($entry_ids);
} else {
ee()->db->where_in('channel_id', $channel_ids);
$num_entries = ee()->db->count_all_results('channel_titles');
}
// --------------------------------------
// Get weighted field settings only, keep track of field ids
// --------------------------------------
$fields = array();
$entries = array();
foreach ($collections as &$col) {
$col['settings'] = array_filter(low_search_decode($col['settings'], FALSE));
// Add field ids to fields array
$fields = array_merge($fields, array_keys($col['settings']));
if (isset($col['entries'])) {
foreach (explode(',', $col['entries']) as $eid) {
$entries[$eid][] = $col['collection_id'];
}
}
}
// Get rid of duplicate field ids
$fields = array_unique($fields);
sort($fields);
// --------------------------------------
// Let an extension take over?
// --------------------------------------
if (ee()->extensions->active_hook('low_search_get_index_entries') === TRUE) {
$index_entries = ee()->extensions->call('low_search_get_index_entries', $fields, $channel_ids, $entry_ids, $start, $batch_size);
} else {
// --------------------------------------
// Create select list
// --------------------------------------
$select = array('t.entry_id', 't.channel_id');
foreach ($fields as $field_id) {
// Skip non-numeric settings
if (!is_numeric($field_id)) {
continue;
}
$select[] = $field_id == '0' ? 't.title AS field_id_0' : 'd.field_id_' . $field_id;
}
// --------------------------------------
// Start building query
// --------------------------------------
ee()->db->select($select)->from('channel_titles t')->join('channel_data d', 't.entry_id = d.entry_id', 'inner')->where_in('t.channel_id', $channel_ids)->order_by('entry_id', 'asc');
// --------------------------------------
// Optional: Limit to given entries
// --------------------------------------
if ($entry_ids) {
ee()->db->where_in('t.entry_id', $entry_ids);
}
// --------------------------------------
// Optional: Limit entries by batch size
// --------------------------------------
if ($start !== FALSE && is_numeric($start)) {
ee()->db->limit($batch_size, $start);
}
// --------------------------------------
// Query it!
// --------------------------------------
$query = ee()->db->get();
// Make sure the rows are keyed by their entry_id
$index_entries = low_associate_results($query->result_array(), 'entry_id');
// --------------------------------------
// Get category info for these entries
// --------------------------------------
if ($entry_cats = $this->get_entry_categories(array_keys($index_entries))) {
// add the categories to the index_entries rows
foreach ($entry_cats as $entry_id => $cats) {
$index_entries[$entry_id] += $cats;
}
}
}
// --------------------------------------
// Loop thru the entries to index
// --------------------------------------
foreach ($index_entries as $row) {
// If it's a given entry, loop thru its collections and rebuild index
if (isset($entries[$row['entry_id']])) {
foreach ($entries[$row['entry_id']] as $col_id) {
// Collection details
$col = $collections[$col_id];
// Build index for this entry/collection combo
ee()->low_search_index_model->build($col, $row);
}
} else {
foreach ($collections as $col_id => $col) {
if ($row['channel_id'] == $col['channel_id']) {
ee()->low_search_index_model->build($col, $row);
}
}
}
}
// Determine new start
$new_start = $start + $batch_size;
// Are we done?
$done = $new_start >= $num_entries;
// --------------------------------------
// Prep response
// --------------------------------------
$response = array('status' => $done ? 'done' : 'building', 'start' => (int) $new_start, 'total_entries' => (int) $num_entries, 'processed' => count($index_entries));
return $response;
}
/**
* Allows for search:title="foo|bar" parameter
*
* @access private
* @return void
*/
public function filter($entry_ids)
{
// --------------------------------------
// Check if search:title is there
// --------------------------------------
$params = $this->params->get_prefixed($this->_pfx, TRUE);
// --------------------------------------
// Don't do anything if nothing's there
// --------------------------------------
if (empty($params)) {
return $entry_ids;
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// --------------------------------------
// Set channel IDs
// --------------------------------------
$this->_channel_ids = ee()->low_search_collection_model->get_channel_ids($this->params->get('collection'));
// --------------------------------------
// Loop through search filters and prep queries accordingly
// --------------------------------------
$queries = array();
foreach ($params as $key => $val) {
// Make sure value is prepped correctly with exact/exclude/require_all values
$val = $this->params->prep($this->_pfx . $key, $val);
// Search channel title
if ($key == 'title') {
// Title search
$queries['channel_titles'][] = $this->_get_where('title', $val);
} elseif (strpos($key, ':')) {
list($field_name, $col_name) = explode(':', $key, 2);
// Skip invalid fields
if (!($field_id = $this->_get_field_id($field_name))) {
continue;
}
$table = FALSE;
// Make sure it's an omelette!
if ($this->_is_grid_field($field_name) && ($col_id = $this->_get_grid_col_id($field_id, $col_name))) {
$table = 'channel_grid_field_' . $field_id;
$field = 'col_id_' . $col_id;
} elseif ($this->_is_matrix_field($field_id) && ($col_id = $this->_get_matrix_col_id($field_id, $col_name))) {
$table = 'matrix_data';
$field = 'col_id_' . $col_id;
}
if ($table) {
$queries[$table][] = $this->_get_where($field, $val);
}
} elseif ($field_id = $this->_get_field_id($key)) {
// Regular fields
$queries['channel_data'][] = $this->_get_where('field_id_' . $field_id, $val);
}
// Don't set it
$this->params->forget[] = $this->_pfx . $key;
}
// --------------------------------------
// Where now contains a list of clauses
// --------------------------------------
if (empty($queries)) {
return $entry_ids;
}
// --------------------------------------
// Query the lot!
// --------------------------------------
foreach ($queries as $table => $wheres) {
// Start this query
ee()->db->distinct()->select('entry_id')->from($table);
// Add wheres
foreach ($wheres as $sql) {
ee()->db->where($sql);
}
// Limit by given entry ids?
if (!empty($entry_ids)) {
ee()->db->where_in('entry_id', $entry_ids);
}
// Limit only for non-grid tables
if (in_array($table, array('channel_titles', 'channel_data'))) {
// Limit by channel
if ($this->_channel_ids) {
ee()->db->where_in('channel_id', $this->_channel_ids);
}
// Limit by site
if ($site_ids = $this->params->site_ids()) {
ee()->db->where_in('site_id', $site_ids);
}
}
// Execute!
$query = ee()->db->get();
// Get entry IDs
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
$entry_ids = array_unique($entry_ids);
// Return immediately when no results are there
if (empty($entry_ids)) {
break;
}
}
return $entry_ids;
}
/**
* Get array of column ids for given Grid or Matrix field
*
* @access private
* @param int
* @param string
* @return array
*/
private function _get_cols($id, $table = 'grid_columns')
{
static $cols = array();
if (!isset($cols[$table][$id])) {
$query = ee()->db->select('col_id')->from($table)->where('field_id', $id)->where('col_search', 'y')->get();
$cols[$table][$id] = low_flatten_results($query->result_array(), 'col_id');
}
return $cols[$table][$id];
}
/**
* Display field in publish form or Matrix cell
*
* @param string Current value for field
* @return string HTML containing input field
*/
private function _display_field($data = '', $cell = FALSE)
{
// -------------------------------------
// What's the field name?
// -------------------------------------
$field_name = $cell ? $this->cell_name : $this->field_name;
// -------------------------------------
// We need groups!
// -------------------------------------
if (empty($this->settings['lv_ft_groups'])) {
return lang('no_variable_group_selected');
}
// -------------------------------------
// Get all variable groups
// -------------------------------------
if (!($groups = low_get_cache($this->package, 'groups'))) {
$query = ee()->db->select('group_id, group_label')->from('low_variable_groups')->where('site_id', ee()->config->item('site_id'))->order_by('group_order')->get();
$groups = low_flatten_results($query->result_array(), 'group_label', 'group_id');
if (!$groups) {
$groups = array();
}
$groups += array('0' => lang('ungrouped'));
low_set_cache($this->package, 'groups', $groups);
}
// -------------------------------------
// Get variables from groups
// -------------------------------------
$query = ee()->db->select('ee.variable_name, low.variable_label, low.group_id')->from('global_variables ee')->join('low_variables low', 'ee.variable_id = low.variable_id')->where('ee.site_id', ee()->config->item('site_id'))->where_in('low.group_id', $this->settings['lv_ft_groups'])->where('low.early_parsing', 'n')->where('low.is_hidden', 'n')->order_by('low.variable_order', 'asc')->get();
// Initiate arrays to get vars by
$unordered_vars = $vars = array();
// Loop through found vars and group by group label
foreach ($query->result_array() as $row) {
$unordered_vars[$row['group_id']][$row['variable_name']] = $row['variable_label'];
}
// Loop through groups (which are in the right order)
// and group the vars by group label to easily create optgroups and such
foreach ($groups as $group_id => $group_label) {
if (isset($unordered_vars[$group_id])) {
$vars[$group_label] = $unordered_vars[$group_id];
}
}
// Reduce to 1 dimensional array
if (count($vars) === 1) {
$vars = $vars[key($vars)];
}
// clean up
unset($unordered_vars);
// -------------------------------------
// Multiple?
// -------------------------------------
if (@$this->settings['lv_ft_multiple'] == 'y') {
// Init arrays for checkboxes
$boxes = array();
$data = explode("\n", $data);
// Loop thru vars and create checkbox in a label
foreach ($vars as $key => $val) {
if (is_array($val)) {
$boxes[] = "<div style=\"margin:1em 0 .5em\"><strong>{$key}</strong></div>";
foreach ($val as $k => $v) {
$boxes[] = $this->_box($field_name, $k, in_array($k, $data), $v);
}
} else {
$boxes[] = $this->_box($field_name, $key, in_array($key, $data), $val);
}
}
// return string of checkboxes
return implode("\n", $boxes);
} else {
$vars = array('' => '--') + $vars;
return form_dropdown($field_name, $vars, $data);
}
}
/**
* Search parameters for range:field params and return set of ids that match it
*
* @access private
* @return void
*/
public function filter($entry_ids)
{
// --------------------------------------
// Get ranges params
// --------------------------------------
$params = array_filter(array_merge($this->params->get_prefixed('range:'), $this->params->get_prefixed('range-from:'), $this->params->get_prefixed('range-to:')), 'low_not_empty');
// --------------------------------------
// Don't do anything if nothing's there
// --------------------------------------
if (empty($params)) {
return $entry_ids;
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// --------------------------------------
// Validate params
// --------------------------------------
$ranges = array();
foreach ($params as $key => $val) {
// Split key
list($prefix, $field) = explode(':', $key, 2);
// Skip invalid fields
if (!($field_name = $this->_get_field_name($field))) {
continue;
}
// Init this range
$from = $to = NULL;
// Check prefix and get from/to values accordingly
switch ($prefix) {
case 'range':
// Fallback to ;
$char = strpos($val, ';') ? ';' : $this->_sep;
if (strpos($val, $char)) {
list($from, $to) = explode($char, $val, 2);
}
break;
case 'range-from':
$from = $val;
break;
case 'range-to':
$to = $val;
break;
}
// Make sure the values are numeric
$from = $this->_validate_value($from, $field);
$to = $this->_validate_value($to, $field);
// If both are invalid, skip it
if (is_null($from) && is_null($to)) {
continue;
}
// Add from value to field
if (!is_null($from)) {
$ranges[$field]['from'] = $from;
}
// Add to value to field
if (!is_null($to)) {
$ranges[$field]['to'] = $to;
}
// Add sql field name to field
$ranges[$field]['field'] = $field_name;
}
// --------------------------------------
// No ranges, bail out
// --------------------------------------
if (empty($ranges)) {
$this->_log('No valid ranges found');
return $entry_ids;
}
// --------------------------------------
// Get channel IDs before starting the query
// --------------------------------------
$channel_ids = ee()->low_search_collection_model->get_channel_ids($this->params->get('collection'));
// --------------------------------------
// Start query
// --------------------------------------
ee()->db->select('t.entry_id')->from('channel_titles t')->join('channel_data d', 't.entry_id = d.entry_id');
// --------------------------------------
// Limit by channel ids?
// --------------------------------------
if ($channel_ids) {
ee()->db->where_in('t.channel_id', $channel_ids);
}
// --------------------------------------
// Limit by site ids?
// --------------------------------------
if ($site_ids = $this->params->site_ids()) {
ee()->db->where_in('t.site_id', $site_ids);
}
// --------------------------------------
// Limit by given entry ids?
// --------------------------------------
if (!empty($entry_ids)) {
ee()->db->where_in('t.entry_id', $entry_ids);
}
// --------------------------------------
// And filter by the ranges
// --------------------------------------
foreach ($ranges as $field => $range) {
// Exclude values from range?
$exclude = $this->params->in_param("range:{$field}", 'exclude');
// Prefix the field name
$sql_field = ($this->_is_native_field($range['field']) ? 't.' : 'd.') . $range['field'];
// Limit by Greater Than option
if (isset($range['from'])) {
$gt = $exclude || $this->params->in_param("range-from:{$field}", 'exclude') ? ' >' : ' >=';
ee()->db->where($sql_field . $gt, $range['from']);
}
// Limit by Lesser Than option
if (isset($range['to'])) {
$lt = $exclude || $this->params->in_param("range-to:{$field}", 'exclude') ? ' <' : ' <=';
ee()->db->where($sql_field . $lt, $range['to']);
}
}
// --------------------------------------
// Execute!
// --------------------------------------
$query = ee()->db->get();
// --------------------------------------
// And get the entry ids
// --------------------------------------
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
$entry_ids = array_unique($entry_ids);
return $entry_ids;
}
/**
* Get the site id and cleaned var from a var="" parameter value
*
* @access private
* @return array
*/
private function _get_var_param()
{
// -------------------------------------
// Get the var parameter value
// -------------------------------------
$var = $this->EE->TMPL->fetch_param('var', FALSE);
// -------------------------------------
// Default site id to current site id
// -------------------------------------
$site_id = $this->site_id;
// -------------------------------------
// Get site id based on site_name:var_name value
// -------------------------------------
if (!empty($var) && ($pos = strpos($var, ':')) !== FALSE) {
// Get the part before the :
$prefix = substr($var, 0, $pos);
// If MSM is enabled and if site name is not current site, fetch its id from cache or DB
if ($this->EE->config->item('multiple_sites_enabled') == 'y') {
// Check cache, if not set, execute query and register to cache
if (($sites = low_get_cache($this->package, 'sites')) === FALSE) {
$query = $this->EE->db->query("SELECT site_id, site_name FROM exp_sites");
$sites = low_flatten_results($query->result_array(), 'site_id', 'site_name');
low_set_cache($this->package, 'sites', $sites);
}
// If the prefix is a site name, strip it from the var name
// and use its id to return
if (array_key_exists($prefix, $sites)) {
$var = substr($var, $pos + 1);
$site_id = $sites[$prefix];
$this->EE->TMPL->log_item("Low Variables: Found var {$var} in site {$prefix}");
}
}
}
// -------------------------------------
// Return the site id and cleaned var name
// ------------------------------------
return array($var, $site_id);
}
/**
* Add early parsed variables to config->_global_vars() array
*
* @access private
* @return void
*/
private function _add_vars($session = FALSE)
{
// -------------------------------------
// Define static var to keep track of
// whether we've added vars already...
// -------------------------------------
static $added;
// ...if so, just bail out
if ($added) {
return;
}
// -------------------------------------
// Initiate data array
// -------------------------------------
$early = array();
// -------------------------------------
// Get global variables to parse early, ordered the way they're displayed in the CP
// -------------------------------------
$query = ee()->db->select(array('ee.variable_name', 'ee.variable_data'))->from('global_variables AS ee')->join('low_variables AS low', 'ee.variable_id = low.variable_id')->where('ee.site_id', $this->site_id)->where('low.early_parsing', 'y')->order_by('low.group_id')->order_by('low.variable_order')->get();
$early = low_flatten_results($query->result_array(), 'variable_data', 'variable_name');
// -------------------------------------
// Are we registering member data?
// -------------------------------------
if ($this->settings['register_member_data'] == 'y') {
// Variables to set
$keys = array('member_id', 'group_id', 'group_description', 'username', 'screen_name', 'email', 'ip_address', 'location', 'total_entries', 'total_comments', 'private_messages', 'total_forum_posts', 'total_forum_topics');
// Add logged_in_... vars to early parsing arrat
foreach ($keys as $key) {
$early['logged_in_' . $key] = $session ? @$session->userdata[$key] : ee()->session->userdata($key);
}
}
// -------------------------------------
// Look for existing language variable, set user language to it
// Disabled for now
// -------------------------------------
// if (isset(ee()->config->_global_vars['global:language']))
// {
// $SESS->userdata['language'] = ee()->config->_global_vars['global:language'];
// }
// -------------------------------------
// Add variables to early parsed global vars
// Option: make it a setting to switch order around?
// -------------------------------------
if ($early) {
ee()->config->_global_vars = $this->settings['register_globals'] == 'y' ? array_merge($early, ee()->config->_global_vars) : array_merge(ee()->config->_global_vars, $early);
}
// Remember that we've added the vars so we don't do it again
$added = TRUE;
}
/**
* Search parameters for (parents|children):field params and return set of ids that match it
*
* @access public
* @return void
*/
public function filter($entry_ids)
{
// --------------------------------------
// Check prefixed parameters needed
// --------------------------------------
$rels = array_filter(array_merge($this->params->get_prefixed('parent:'), $this->params->get_prefixed('child:')), 'low_param_is_numeric');
// --------------------------------------
// Don't do anything if nothing's there
// --------------------------------------
if (empty($rels)) {
return $entry_ids;
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// --------------------------------------
// Loop through relationships
// --------------------------------------
foreach ($rels as $key => $val) {
// List out match
list($type, $field) = explode(':', $key, 2);
// Get the field id, skip if non-existent
if (!($field_id = $this->_get_field_id($field))) {
continue;
}
// Prep the value
$val = $this->params->prep($key, $val);
// Get the parameter
list($ids, $in) = low_explode_param($val);
// Match all?
$all = (bool) strpos($val, '&');
// Init vars
$rel_ids = $table = FALSE;
$get_children = $type == 'parent';
// Native relationship field
if ($this->_is_rel_field($field)) {
// Account for new EE rels
$prefix = version_compare(APP_VER, '2.6.0', '<') ? 'rel_' : '';
// Set the table & attributes
$table = 'relationships';
$select = $get_children ? $prefix . 'child_id' : $prefix . 'parent_id';
$where = $get_children ? $prefix . 'parent_id' : $prefix . 'child_id';
} elseif ($this->_is_playa_field($field_id)) {
// Set the table
$table = 'playa_relationships';
$select = $get_children ? 'child_entry_id' : 'parent_entry_id';
$where = $get_children ? 'parent_entry_id' : 'child_entry_id';
// Focus on specific field
ee()->db->where('parent_field_id', $field_id);
}
// Execute query
if ($table) {
ee()->db->select($select . ' AS entry_id')->from($table)->{$in ? 'where_in' : 'where_not_in'}($where, $ids);
// Limit by already existing ids
if ($entry_ids) {
ee()->db->where_in($select, $entry_ids);
}
// Do the having-trick to account for *all* given entry ids
if ($in && $all) {
ee()->db->select('COUNT(*) AS num')->group_by($select)->having('num', count($ids));
}
// Execute query
$query = ee()->db->get();
// And get the entry ids
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
$entry_ids = array_unique($entry_ids);
// Bail out if there aren't any matches
if (is_array($entry_ids) && empty($entry_ids)) {
break;
}
}
}
return $entry_ids;
}
/**
* Sync EE vars and Low vars
*
* Deletes Low Variables that reference to non-existing EE Variables,
* Creates default Low Variables that have no reference to existing EE Vars.
*
* @access private
* @return void
*/
private function _sync()
{
// -------------------------------------
// Get all native variable ids
// -------------------------------------
$query = ee()->db->select('variable_id')->from('global_variables')->get();
$ee_ids = low_flatten_results($query->result_array(), 'variable_id');
// -------------------------------------
// Sync based on ee ids
// -------------------------------------
if (!empty($ee_ids)) {
// Delete references to non-existing native vars
ee()->db->where_not_in('variable_id', $ee_ids)->delete('low_variables');
// Get all Low Variables
$query = ee()->db->select('variable_id')->from('low_variables')->get();
$low_ids = low_flatten_results($query->result_array(), 'variable_id');
// Get ids that do not exist in low_var but do exist in ee_var
if ($diff = array_diff($ee_ids, $low_ids)) {
foreach ($diff as $i => $var_id) {
ee()->db->insert('low_variables', array('variable_id' => $var_id, 'group_id' => '0', 'variable_label' => '', 'variable_notes' => '', 'variable_type' => LOW_VAR_DEFAULT_TYPE, 'variable_settings' => '', 'variable_order' => $i, 'edit_date' => time()));
}
}
}
}
/**
* Display input field for regular user
*
* @param int $var_id The id of the variable
* @param string $var_data The value of the variable
* @param array $var_settings The settings of the variable
* @return string
*/
function display_input($var_id, $var_data, $var_settings)
{
// -------------------------------------
// Prep options
// -------------------------------------
$category_groups = $this->get_setting('category_groups', $var_settings);
$multiple = $this->get_setting('multiple', $var_settings);
$separator = $this->get_setting('separator', $var_settings);
$multi_interface = $this->get_setting('multi_interface', $var_settings);
// -------------------------------------
// Prep current data
// -------------------------------------
$current = explode($this->separators[$separator], $var_data);
// -------------------------------------
// No groups? Bail.
// -------------------------------------
if (empty($category_groups)) {
return lang('no_category_groups_selected');
}
// -------------------------------------
// Load category API and fetch categories
// -------------------------------------
ee()->load->library('api');
ee()->api->instantiate('channel_categories');
$categories = ee()->api_channel_categories->category_tree($category_groups);
// -------------------------------------
// Compose nested category array
// -------------------------------------
$cats = array();
if ($multiple == 'y' && $multi_interface == 'drag-list') {
// This will return a flat list of categories
$cats = low_flatten_results($categories, '1', '0');
// So we need to sort alphabetically again
asort($cats);
// Then assign to output
$r = $this->drag_lists($var_id, $cats, $current);
} else {
// Loop thru tree and create nested array accordingly
foreach ($categories as $row) {
// Category name
$cat = $row['1'];
// Check indent level
if ($row['5'] > 1) {
$cat = str_repeat('-', $row['5'] - 1) . ' ' . $cat;
}
$cats[$row['3']][$row['0']] = $cat;
}
// Sort if multiple groups
if (count($cats) > 1) {
ksort($cats);
}
// Assign regular select element to output
$r = $this->select_element($var_id, $cats, $current, $multiple == 'y');
}
// -------------------------------------
// Return interface
// -------------------------------------
return $r;
}
/**
* Update by category
*/
private function _update_index_by_category($cat_ids)
{
if (empty($cat_ids)) {
return $cat_ids;
}
// Get entries for this category
$query = ee()->db->select('entry_id')->from('category_posts')->where_in('cat_id', $cat_ids)->get();
$entry_ids = low_flatten_results($query->result_array(), 'entry_id');
$entry_ids = array_unique($entry_ids);
if ($entry_ids) {
ee()->load->library('Low_search_index');
ee()->low_search_index->build(FALSE, $entry_ids);
}
}
/**
* Do update to 1.3.4
*/
private function _v134()
{
// Add group_id foreign key in table
$this->EE->db->query("ALTER TABLE `exp_low_variables` ADD `is_hidden` CHAR(1) NOT NULL DEFAULT 'n'");
// Set new attribute, only if settings are found
if ($settings = low_get_cache(LOW_VAR_PACKAGE, 'settings')) {
// Only update variables if prefix was filled in
if ($prefix_length = strlen(@$settings['prefix'])) {
$sql = "SELECT variable_id FROM `exp_global_variables` WHERE LEFT(variable_name, {$prefix_length}) = '" . $this->EE->db->escape_str($settings['prefix']) . "'";
$query = $this->EE->db->query($sql);
if ($ids = low_flatten_results($query->result_array(), 'variable_id')) {
// Hide wich vars
$sql_in = $settings['with_prefixed'] == 'show' ? 'NOT IN' : 'IN';
// Execute query
$this->EE->db->query("UPDATE `exp_low_variables` SET is_hidden = 'y' WHERE variable_id {$sql_in} (" . implode(',', $ids) . ")");
}
}
// Update settings
unset($settings['prefix'], $settings['with_prefixed'], $settings['ignore_prefixes']);
$this->EE->db->query("UPDATE `exp_extensions` SET settings = '" . $this->EE->db->escape_str(serialize($settings)) . "' WHERE class = 'Low_variables_ext'");
}
}
/**
* Save set settings
*
* @access public
* @return void
*/
public function save_set()
{
// --------------------------------------
// Get Set id
// --------------------------------------
if (!($set_id = ee()->input->post('set_id'))) {
return $this->_show_error('invalid_request');
}
// --------------------------------------
// Init data array
// --------------------------------------
$data = array();
// --------------------------------------
// Regular fields
// --------------------------------------
foreach (ee()->low_reorder_set_model->attributes() as $attr) {
$data[$attr] = ee()->input->post($attr);
}
// Clean up params
$data['parameters'] = array_filter($data['parameters']);
// --------------------------------------
// Validate some fields
// --------------------------------------
// Label shouldn't be empty
if (empty($data['set_label'])) {
show_error(lang('set_label_empty'));
}
// Set name should be valid
if (!preg_match('/^[-_\\w]+$/i', $data['set_name'])) {
show_error(lang('set_name_invalid'));
}
// Check if set name is unique for this site
if (!ee()->low_reorder_set_model->name_is_unique($set_id, $data['set_name'], $this->site_id)) {
show_error(lang('set_name_not_unique'));
}
// Channels shouldn't be empty
if (empty($data['channels'])) {
show_error(lang('channels_empty'));
}
// Default to status = open if none are given
if (empty($data['parameters']['status'])) {
$data['parameters']['status'][] = 'open';
}
// Cat groups are required for 'one'
if ($data['cat_option'] == 'one') {
if (empty($data['cat_groups'])) {
show_error(lang('cat_groups_empty'));
}
} else {
// If not set to 'one', set cat_groups to empty
$data['cat_groups'] = '';
}
// Unset category parameter
if ($data['cat_option'] != 'some') {
unset($data['parameters']['category']);
}
// Set clear_cache to 'y' or 'n'
$data['clear_cache'] = $data['clear_cache'] == 'yes' ? 'y' : 'n';
// --------------------------------------
// Set site id
// --------------------------------------
$data['site_id'] = $this->site_id;
// --------------------------------------
// Get parameters
// --------------------------------------
// Store channel_short_names in parameters
if (!empty($data['channels'])) {
$query = ee()->db->select('channel_name')->from('channels')->where_in('channel_id', $data['channels'])->get();
$data['parameters']['channel'] = implode('|', low_flatten_results($query->result_array(), 'channel_name'));
}
// --------------------------------------
// Add search filters to parameters
// --------------------------------------
if ($search = ee()->input->post('search')) {
foreach ($search['fields'] as $i => $key) {
$val = (string) @$search['values'][$i];
if (strlen($key) && strlen($val)) {
$data['parameters']["search:{$key}"] = $val;
}
}
}
// --------------------------------------
// Get parameters and permissions
// --------------------------------------
$data['parameters'] = ee()->low_reorder_set_model->get_params($data['parameters']);
$data['permissions'] = (array) ee()->input->post('permissions');
// Copy data to $sql_data
$sql_data = $data;
// --------------------------------------
// Convert sql_data to strings
// --------------------------------------
$sql_data['parameters'] = json_encode($sql_data['parameters']);
$sql_data['permissions'] = json_encode($sql_data['permissions']);
foreach ($sql_data as &$val) {
if (is_array($val)) {
$val = count($val) ? low_linearize($val) : '';
}
}
// --------------------------------------
// Insert or Update
// --------------------------------------
if ($set_id == 'new') {
$set_id = ee()->low_reorder_set_model->insert($sql_data);
} else {
ee()->low_reorder_set_model->update($set_id, $sql_data);
}
// --------------------------------------
// Insert order
// --------------------------------------
// Prep params
$params = $data['parameters'] + array('channel_id' => implode('|', $data['channels']));
// Account for uncategorized entries
if ($data['cat_option'] == 'none') {
$params['uncategorized_entries'] = 'yes';
}
// Initiate orders for all categories
if ($data['cat_option'] == 'one') {
$query = ee()->db->select("c.cat_id, GROUP_CONCAT(t.entry_id ORDER BY t.entry_date DESC SEPARATOR '|') AS entry_ids", FALSE)->from('channel_titles t')->join('category_posts cp', 't.entry_id = cp.entry_id')->join('categories c', 'c.cat_id = cp.cat_id')->where_in('t.channel_id', $data['channels'])->where_in('t.status', explode('|', $data['parameters']['status']))->where_in('c.group_id', $data['cat_groups'])->group_by('c.cat_id')->get();
foreach ($query->result() as $row) {
ee()->low_reorder_order_model->insert_ignore(array('set_id' => $set_id, 'cat_id' => $row->cat_id, 'sort_order' => $row->entry_ids ? "|{$row->entry_ids}|" : ''));
}
} else {
$entries = low_flatten_results($this->get_entries($params), 'entry_id');
ee()->low_reorder_order_model->insert_ignore(array('set_id' => $set_id, 'cat_id' => 0, 'sort_order' => low_linearize($entries)));
}
// -------------------------------------
// 'low_reorder_post_save_set' hook.
// - Do something after the (new) set has been saved
// -------------------------------------
if (ee()->extensions->active_hook('low_reorder_post_save_set') === TRUE) {
// Use raw, non-encoded data to pass through
ee()->extensions->call('low_reorder_post_save_set', $set_id, $data);
}
// --------------------------------------
// Set feedback message
// --------------------------------------
ee()->session->set_flashdata('msg', lang('settings_saved'));
// --------------------------------------
// Go back to set or reoder page
// --------------------------------------
$method = ee()->input->post('reorder') ? 'reorder' : 'edit';
ee()->functions->redirect($this->base_url . AMP . 'method=' . $method . AMP . 'set_id=' . $set_id);
}
/**
* Get channel IDs by parameter
*/
public function get_channel_ids($param)
{
$channel_ids = array();
if ($param) {
$cols = $this->get_by_param($param);
$channel_ids = low_flatten_results($cols, 'channel_id');
$channel_ids = array_unique($channel_ids);
}
return $channel_ids;
}
/**
* Search parameters for distance: params
*
* @access private
* @return void
*/
public function filter($entry_ids)
{
// --------------------------------------
// Reset
// --------------------------------------
$this->_results = array();
// --------------------------------------
// Get distance params
// --------------------------------------
$params = $this->params->get_prefixed('distance:', TRUE);
$params = array_filter($params, 'low_not_empty');
// --------------------------------------
// Check required params
// --------------------------------------
foreach (array('from', 'to') as $key) {
if (empty($params[$key])) {
return $entry_ids;
}
}
// --------------------------------------
// Log it
// --------------------------------------
$this->_log('Applying ' . __CLASS__);
// --------------------------------------
// Get channel IDs before starting the query
// --------------------------------------
$channel_ids = ee()->low_search_collection_model->get_channel_ids($this->params->get('collection'));
// --------------------------------------
// Get from coords
// --------------------------------------
list($lat, $long) = preg_split('/[|,]/', $params['from'], 2, PREG_SPLIT_NO_EMPTY);
// --------------------------------------
// Unit
// --------------------------------------
if (empty($params['unit'])) {
$params['unit'] = 'km';
}
// Radius of the earth
switch ($params['unit']) {
case 'mi':
$R = 3959;
break;
default:
$R = 6371;
}
// --------------------------------------
// Get reference to fields from params
// --------------------------------------
list($lat_field, $long_field) = explode('|', $params['to'], 2);
$lat_field_id = $this->_get_field_id($lat_field);
$long_field_id = $this->_get_field_id($long_field);
if (!($lat_field_id && $long_field_id)) {
return $entry_ids;
}
$lat_field = 'field_id_' . $lat_field_id;
$long_field = 'field_id_' . $long_field_id;
// --------------------------------------
// The distance SQL statement: Haversine formula
// --------------------------------------
$haversine = '(%d * acos(cos(radians(%2$f)) * cos(radians(%4$s)) * cos(radians(%5$s) - radians(%3$f))' . ' + sin(radians(%2$f)) * sin(radians(%4$s)))) AS distance';
// Get entry IDs and their distances
ee()->db->select('entry_id')->select(sprintf($haversine, $R, $lat, $long, $lat_field, $long_field), FALSE)->from('channel_data')->where("({$lat_field} OR {$long_field})")->order_by('distance', 'asc');
// --------------------------------------
// Limit by site ids?
// --------------------------------------
if ($site_ids = $this->params->site_ids()) {
ee()->db->where_in('site_id', $site_ids);
}
// --------------------------------------
// Limit by channel ids?
// --------------------------------------
if ($channel_ids) {
ee()->db->where_in('channel_id', $channel_ids);
}
// --------------------------------------
// Limit by entry ids?
// --------------------------------------
if ($entry_ids) {
ee()->db->where_in('entry_id', $entry_ids);
}
// --------------------------------------
// Limit by radius?
// --------------------------------------
if (!empty($params['radius'])) {
ee()->db->having('distance <=', $params['radius']);
}
// --------------------------------------
// Execute!
// --------------------------------------
$query = ee()->db->get();
$this->_results = low_flatten_results($query->result_array(), 'distance', 'entry_id');
return array_keys($this->_results);
}
/**
* Get shortcuts for given group
*
* @access public
* @return void
*/
public function get_group_counts($site_id)
{
$query = ee()->db->select('group_id, COUNT(*) AS num')->from($this->table())->where('site_id', $site_id)->group_by('group_id')->get();
return low_flatten_results($query->result_array(), 'num', 'group_id');
}