a22573bf0b
- WordPress core y plugins - Tema Twenty Twenty-Four configurado - Plugin allow-unfiltered-html.php simplificado - .gitignore configurado para excluir wp-config.php y uploads 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
1444 lines
50 KiB
PHP
Executable File
1444 lines
50 KiB
PHP
Executable File
<?php /** @noinspection DuplicatedCode */
|
|
|
|
namespace WPDRMS\ASP\Query;
|
|
|
|
use WPDRMS\ASP\Index\Manager;
|
|
use WPDRMS\ASP\Models\SearchQueryArgs;
|
|
use WPDRMS\ASP\Options\Data\SearchOptions;
|
|
use WPDRMS\ASP\Utils\Str;
|
|
use WPDRMS\ASP\Utils\WPMU;
|
|
|
|
defined('ABSPATH') || die("You can't access this file directly.");
|
|
|
|
class QueryArgs {
|
|
/**
|
|
* Translates search data and $_POST options to query arguments to use with SearchQuery
|
|
*
|
|
* @param int $search_id
|
|
* @param array<string, mixed> $o
|
|
* @param array<string, mixed> $args
|
|
* @return array<string, mixed>
|
|
* @noinspection PhpUndefinedFunctionInspection
|
|
*/
|
|
public static function get( int $search_id, array $o = array(), array $args = array() ): array {
|
|
|
|
// Always return an emtpy array if something goes wrong
|
|
if ( !wd_asp()->instances->exists($search_id) ) {
|
|
return array();
|
|
}
|
|
|
|
$search = wd_asp()->instances->get($search_id);
|
|
$sd = $search['data'];
|
|
/**
|
|
* @var SearchOptions $search_options
|
|
*/
|
|
$search_options = $search->options;
|
|
// See if we post the preview data through
|
|
// phpcs:disable
|
|
if ( !empty($_POST['asp_preview_options']) && ( current_user_can('manage_options') || ASP_DEMO ) ) {
|
|
if ( is_array($_POST['asp_preview_options']) ) {
|
|
$sd = array_merge($sd, $_POST['asp_preview_options']);
|
|
$search_options->setData( $sd );
|
|
} else {
|
|
parse_str($_POST['asp_preview_options'], $preview_options);
|
|
$sd = array_merge($sd, $preview_options);
|
|
$search_options->setData( $sd );
|
|
}
|
|
}
|
|
// phpcs:enable
|
|
|
|
// $args = empty($args) ? SearchQuery::$defaults : array_merge(SearchQuery::$defaults, $args);
|
|
$comp_options = wd_asp()->o['asp_compatibility'];
|
|
$it_options = wd_asp()->o['asp_it_options'];
|
|
|
|
$exclude_post_ids = array_unique(
|
|
array_merge(
|
|
$sd['exclude_cpt']['ids'],
|
|
explode(',', str_replace(' ', '', $sd['excludeposts']))
|
|
)
|
|
);
|
|
foreach ( $exclude_post_ids as $k =>$v ) {
|
|
if ( $v === '' ) {
|
|
unset($exclude_post_ids[ $k ]);
|
|
} else {
|
|
$exclude_post_ids[ $k ] = intval($v);
|
|
}
|
|
}
|
|
|
|
$include_post_ids = array_unique($sd['include_cpt']['ids']);
|
|
foreach ( $include_post_ids as $k =>$v ) {
|
|
if ( $v === '' ) {
|
|
unset($include_post_ids[ $k ]);
|
|
}
|
|
}
|
|
|
|
// Parse the filters, so the objects exist
|
|
asp_parse_filters($search_id, $sd, true, false);
|
|
|
|
// ----------------------------------------------------------------
|
|
// 1. CPT + INDEXTABLE
|
|
// ----------------------------------------------------------------
|
|
$args = array_merge(
|
|
$args,
|
|
array(
|
|
'_sd' => $sd, // Search Data
|
|
'search_options' => $search_options,
|
|
'_id' => $search_id,
|
|
'keyword_logic' => $sd['keyword_logic'],
|
|
'secondary_logic' => $sd['secondary_kw_logic'],
|
|
'engine' => $sd['search_engine'],
|
|
'post_not_in' => $exclude_post_ids,
|
|
'post_in' => $include_post_ids,
|
|
'post_primary_order' => $sd['orderby_primary'],
|
|
'post_secondary_order' => $sd['orderby_secondary'],
|
|
'post_meta_allow_missing' => $sd['cf_allow_null'],
|
|
'post_meta_filter_logic' => $sd['cf_logic'],
|
|
'_post_use_relevance' => $sd['userelevance'],
|
|
'_db_force_case' => $comp_options['db_force_case'],
|
|
'_db_force_utf8_like' => $comp_options['db_force_utf8_like'],
|
|
'_db_force_unicode' => $comp_options['db_force_unicode'],
|
|
'_post_allow_empty_tax_term' => $sd['frontend_terms_empty'],
|
|
'_taxonomy_group_logic' => $sd['taxonomy_logic'],
|
|
|
|
// LIMITS
|
|
'posts_limit' => intval($sd['posts_limit']),
|
|
'posts_limit_override' => intval($sd['posts_limit_override']),
|
|
'posts_limit_distribute' => $sd['posts_limit_distribute'], // this is bool
|
|
'taxonomies_limit' => intval($sd['taxonomies_limit']),
|
|
'taxonomies_limit_override' => intval($sd['taxonomies_limit_override']),
|
|
'users_limit' => intval($sd['users_limit']),
|
|
'users_limit_override' => intval($sd['users_limit_override']),
|
|
'blogs_limit' => intval($sd['blogs_limit']),
|
|
'blogs_limit_override' => intval($sd['blogs_limit_override']),
|
|
'buddypress_limit' => intval($sd['buddypress_limit']),
|
|
'buddypress_limit_override' => intval($sd['buddypress_limit_override']),
|
|
'comments_limit' => intval($sd['comments_limit']),
|
|
'comments_limit_override' => intval($sd['comments_limit_override']),
|
|
'attachments_limit' => intval($sd['attachments_limit']),
|
|
'attachments_limit_override' => intval($sd['attachments_limit_override']),
|
|
)
|
|
);
|
|
$args['_qtranslate_lang'] = $o['qtranslate_lang'] ?? '';
|
|
|
|
if ( $sd['polylang_compatibility'] ) {
|
|
$args['_polylang_lang'] = $o['polylang_lang'] ?? ( function_exists('pll_current_language') ? pll_current_language() : '' );
|
|
}
|
|
|
|
// Exclusions via the options (auto populate)
|
|
if ( isset($o['not_in']) ) {
|
|
if ( isset($o['not_in']['pagepost']) && is_array($o['not_in']['pagepost']) ) {
|
|
if ( !isset($args['post_not_in']) ) {
|
|
$args['post_not_in'] = array();
|
|
}
|
|
$args['post_not_in'] = array_unique(
|
|
array_merge(
|
|
$args['post_not_in'],
|
|
array_map('intval', $o['not_in']['pagepost'])
|
|
)
|
|
);
|
|
}
|
|
if ( isset($o['not_in']['attachment']) && is_array($o['not_in']['attachment']) ) {
|
|
if ( !isset($args['attachment_exclude']) ) {
|
|
$args['attachment_exclude'] = array();
|
|
}
|
|
$args['attachment_exclude'] = array_unique(
|
|
array_merge(
|
|
$args['attachment_exclude'],
|
|
array_map('intval', $o['not_in']['attachment'])
|
|
)
|
|
);
|
|
}
|
|
if ( isset($o['not_in']['term']) && is_array($o['not_in']['term']) ) {
|
|
if ( !isset($args['taxonomy_terms_exclude2']) ) {
|
|
$args['taxonomy_terms_exclude2'] = array();
|
|
}
|
|
$args['taxonomy_terms_exclude2'] = array_unique(
|
|
array_merge(
|
|
$args['taxonomy_terms_exclude2'],
|
|
array_map('intval', $o['not_in']['term'])
|
|
)
|
|
);
|
|
}
|
|
if ( isset($o['not_in']['user']) && is_array($o['not_in']['user']) ) {
|
|
if ( !isset($args['user_search_exclude_ids']) ) {
|
|
$args['user_search_exclude_ids'] = array();
|
|
}
|
|
$args['user_search_exclude_ids'] = array_unique(
|
|
array_merge(
|
|
$args['user_search_exclude_ids'],
|
|
array_map('intval', $o['not_in']['user'])
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( in_array('exact', $sd['frontend_fields']['selected'], true) ) {
|
|
$args['_exact_matches'] = isset($o['asp_gen']) && is_array($o['asp_gen']) && in_array('exact', $o['asp_gen'], true);
|
|
} else {
|
|
$args['_exact_matches'] = $sd['exactonly'];
|
|
}
|
|
|
|
$args['_exact_match_location'] = $sd['exact_match_location'];
|
|
|
|
// Is the secondary logic allowed on exact matching?
|
|
if ( $args['_exact_matches'] && !$sd['exact_m_secondary'] ) {
|
|
$args['secondary_logic'] = 'none';
|
|
}
|
|
|
|
// Minimal word length to be a keyword
|
|
$args['min_word_length'] = $sd['min_word_length'];
|
|
|
|
/*----------------------- Meta key order ------------------------*/
|
|
if ( strpos($sd['orderby_primary'], 'customfp') !== false ) {
|
|
if ( !empty($sd['orderby_primary_cf']) ) {
|
|
$args['_post_primary_order_metakey'] = $sd['orderby_primary_cf'];
|
|
$args['post_primary_order_metatype'] = $sd['orderby_primary_cf_type'];
|
|
}
|
|
}
|
|
if ( strpos($sd['orderby_secondary'], 'customfs') !== false ) {
|
|
if ( !empty($sd['orderby_secondary_cf']) ) {
|
|
$args['_post_secondary_order_metakey'] = $sd['orderby_secondary_cf'];
|
|
$args['post_secondary_order_metatype'] = $sd['orderby_secondary_cf_type'];
|
|
}
|
|
}
|
|
|
|
/*----------------------- Auto populate -------------------------*/
|
|
if ( isset($o['force_count']) ) {
|
|
// Set the advanced limit parameter to be distributed later
|
|
$args['limit'] = intval($o['force_count']);
|
|
}
|
|
if ( isset($o['force_order']) ) {
|
|
if ( intval($o['force_order']) === 1 ) {
|
|
$args['post_primary_order'] = 'post_date DESC';
|
|
} elseif ( intval($o['force_order']) === 2 ) {
|
|
$args['post_primary_order'] = 'RAND()';
|
|
}
|
|
}
|
|
|
|
/*------------------------- Statuses ----------------------------*/
|
|
$args['post_status'] = explode(',', str_replace(' ', '', $sd['post_status']));
|
|
|
|
/*--------------------- Password protected ----------------------*/
|
|
$args['has_password'] = $sd['post_password_protected'];
|
|
|
|
/*----------------------- Gather Types --------------------------*/
|
|
$args['post_type'] = $sd['customtypes'];
|
|
if ( isset($o['customset']) ) {
|
|
$frontend_custom_post_types = array();
|
|
foreach ( wd_asp()->front_filters->get('position', 'post_type') as $filter ) { // @phpstan-ignore-line
|
|
foreach ( $filter->get() as $item ) {
|
|
$frontend_custom_post_types[] = $item->value;
|
|
}
|
|
}
|
|
$args['post_type'] = array_diff($args['post_type'], $frontend_custom_post_types);
|
|
if ( isset($o['customset']) && is_array($o['customset']) && count( $o['customset'] ) > 0 ) {
|
|
$o['customset'] = Str::escape( $o['customset'], true, ' ;:.,(){}@[]!?&|#^=' );
|
|
if ( in_array(-1, $o['customset']) ) { // phpcs:ignore
|
|
$args['post_type'] = $sd['customtypes'];
|
|
} else {
|
|
$args['post_type'] = array_unique( array_merge($args['post_type'], $o['customset']) );
|
|
}
|
|
}
|
|
}
|
|
foreach ( $args['post_type'] as $vv ) {
|
|
if ( $vv === 'page' && count($sd['exclude_cpt']['parent_ids']) > 0 ) {
|
|
$args['_exclude_page_parent_child'] = array_map('intval', $sd['exclude_cpt']['parent_ids']);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*--------------------- OTHER FILTER RELATED --------------------*/
|
|
$args['filters_changed'] = $o['filters_changed'] ?? ( $args['filters_changed'] ?? false );
|
|
$args['filters_initial'] = $o['filters_initial'] ?? ( $args['filters_initial'] ?? true );
|
|
|
|
/*--------------------- GENERAL FIELDS --------------------------*/
|
|
$args['search_type'] = array();
|
|
$args['post_fields'] = array();
|
|
|
|
if ( $args['engine'] === 'regular' ) {
|
|
if ( $sd['searchinterms'] ) {
|
|
$args['post_fields'][] = 'terms';
|
|
}
|
|
if ( $sd['searchintitle'] ) {
|
|
$args['post_fields'][] = 'title';
|
|
}
|
|
if ( $sd['searchincontent'] ) {
|
|
$args['post_fields'][] = 'content';
|
|
}
|
|
if ( $sd['searchinexcerpt'] ) {
|
|
$args['post_fields'][] = 'excerpt';
|
|
}
|
|
} else {
|
|
$args['post_fields'][] = 'terms';
|
|
if ( $it_options['it_index_title'] ) {
|
|
$args['post_fields'][] = 'title';
|
|
}
|
|
if ( $it_options['it_index_content'] ) {
|
|
$args['post_fields'][] = 'content';
|
|
}
|
|
if ( $it_options['it_index_excerpt'] ) {
|
|
$args['post_fields'][] = 'excerpt';
|
|
}
|
|
}
|
|
|
|
if ( is_array($o) ) {
|
|
$frontend_generic_filters = array();
|
|
foreach ( wd_asp()->front_filters->get('position', 'generic') as $filter ) { // @phpstan-ignore-line
|
|
foreach ( $filter->get() as $item ) {
|
|
$frontend_generic_filters[] = $item->value;
|
|
}
|
|
}
|
|
$_original_post_fields = $args['post_fields'];
|
|
$args['post_fields'] = array_diff($args['post_fields'], $frontend_generic_filters);
|
|
if ( isset($o['asp_gen']) && is_array($o['asp_gen']) ) {
|
|
if ( in_array(-1, $o['asp_gen']) ) { // phpcs:ignore
|
|
$args['post_fields'] = $_original_post_fields;
|
|
} else {
|
|
$args['post_fields'] = array_unique(array_merge($args['post_fields'], $o['asp_gen']));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( $sd['search_in_ids'] ) {
|
|
$args['post_fields'][] = 'ids';
|
|
}
|
|
if ( $sd['search_in_permalinks'] ) {
|
|
$args['post_fields'][] = 'permalink';
|
|
}
|
|
|
|
/*--------------------- CUSTOM FIELDS ---------------------------*/
|
|
$args['post_custom_fields_all'] = (bool) $sd['search_all_cf'];
|
|
$args['post_custom_fields'] = $sd['selected-customfields'] ?? array();
|
|
|
|
if ( count($args['post_fields']) > 0 ||
|
|
$args['post_custom_fields_all'] ||
|
|
count($args['post_custom_fields']) > 0 ||
|
|
count($args['post_type']) > 0
|
|
) {
|
|
$args['search_type'][] = 'cpt';
|
|
}
|
|
|
|
// Are there any additional tags?
|
|
if (
|
|
count(wd_asp()->o['asp_glob']['additional_tag_posts']) > 0 &&
|
|
!in_array('_asp_additional_tags', $args['post_custom_fields'], true)
|
|
) {
|
|
$args['post_custom_fields'][] = '_asp_additional_tags';
|
|
}
|
|
|
|
/*-------------------------- WPML -------------------------------*/
|
|
if ( $sd['wpml_compatibility'] ) {
|
|
if ( isset( $o['wpml_lang'] ) && $args['_ajax_search'] ) {
|
|
$args['_wpml_lang'] = $o['wpml_lang'];
|
|
} elseif (
|
|
defined('ICL_LANGUAGE_CODE')
|
|
&& !empty(ICL_LANGUAGE_CODE) // It can be null, so better be safe
|
|
&& defined('ICL_SITEPRESS_VERSION')
|
|
) {
|
|
$args['_wpml_lang'] = ICL_LANGUAGE_CODE;
|
|
}
|
|
|
|
/**
|
|
* Switching the language will resolve issues with get_terms(...) and other functions
|
|
* Otherwise wrong taxonomy terms would be returned etc...
|
|
*/
|
|
global $sitepress;
|
|
if ( is_object($sitepress) && method_exists($sitepress, 'switch_lang') ) {
|
|
$sitepress->switch_lang($args['_wpml_lang']);
|
|
}
|
|
}
|
|
|
|
/*-------------------- Content, Excerpt -------------------------*/
|
|
$args['_post_get_content'] = (
|
|
$sd['showdescription'] ||
|
|
( $sd['resultstype'] === 'isotopic' && $sd['i_ifnoimage'] === 'description' ) ||
|
|
( $sd['resultstype'] === 'polaroid' && ( $sd['pifnoimage'] === 'descinstead' || $sd['pshowdesc'] ) )
|
|
);
|
|
$args['_post_get_excerpt'] = (
|
|
$sd['primary_titlefield'] ||
|
|
$sd['secondary_titlefield'] ||
|
|
$sd['primary_descriptionfield'] ||
|
|
$sd['secondary_descriptionfield']
|
|
);
|
|
|
|
/*---------------------- Taxonomy Terms -------------------------*/
|
|
$args['post_tax_filter'] = self::getTaxonomyArgs($sd, $o);
|
|
|
|
/*--------------------------- Tags ------------------------------*/
|
|
self::getTagArgs($sd, $o, $args);
|
|
|
|
/*----------------------- Custom Fields -------------------------*/
|
|
$args['post_meta_filter'] = self::getCustomFieldArgs($sd, $o);
|
|
|
|
/*----------------------- Date Filters --------------------------*/
|
|
$args['post_date_filter'] = self::getDateArgs($sd, $o);
|
|
|
|
/*----------------------- User Filters --------------------------*/
|
|
if ( count($sd['exclude_content_by_users']['users']) ) {
|
|
foreach ( $sd['exclude_content_by_users']['users'] as $uk => $uv ) {
|
|
if ( intval($uv) === -2 ) {
|
|
$sd['exclude_content_by_users']['users'][ $uk ] = get_current_user_id();
|
|
}
|
|
}
|
|
$args['post_user_filter'][ $sd['exclude_content_by_users']['op_type'] ] = $sd['exclude_content_by_users']['users'];
|
|
}
|
|
|
|
/*---------------------- Selected blogs -------------------------*/
|
|
$sd['selected-blogs'] = w_isset_def($sd['selected-blogs'], array( 0 => get_current_blog_id() ));
|
|
if ( $sd['selected-blogs'] === 'all' ) {
|
|
if ( is_multisite() ) {
|
|
$args['_selected_blogs'] = WPMU::getBlogList(true);
|
|
} else {
|
|
$args['_selected_blogs'] = array( 0 => get_current_blog_id() );
|
|
}
|
|
} else {
|
|
$args['_selected_blogs'] = $sd['selected-blogs'];
|
|
}
|
|
if ( count($args['_selected_blogs']) <= 0 ) {
|
|
$args['_selected_blogs'] = array( 0 => get_current_blog_id() );
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// 2. ATTACHMENTS
|
|
// ----------------------------------------------------------------
|
|
if ( $sd['return_attachments'] ) {
|
|
$args['search_type'][] = 'attachments';
|
|
}
|
|
/*-------------------- Allowed mime types -----------------------*/
|
|
if ( $sd['attachment_mime_types'] !== '' ) {
|
|
$args['attachment_mime_types'] = wpd_comma_separated_to_array($sd['attachment_mime_types']);
|
|
foreach ( $args['attachment_mime_types'] as $k => $v ) {
|
|
$args['attachment_mime_types'][ $k ] = trim($v);
|
|
}
|
|
}
|
|
/*------------------------ Exclusions ---------------------------*/
|
|
|
|
if ( $sd['attachment_exclude'] !== '' ) {
|
|
$args['attachment_exclude'] = explode(',', str_replace(' ', '', $sd['attachment_exclude']));
|
|
}
|
|
|
|
$args['attachments_use_index'] = $sd['attachments_use_index'] === 'index';
|
|
$args['attachments_search_terms'] = $sd['search_attachments_terms'];
|
|
$args['attachments_search_title'] = $sd['search_attachments_title'];
|
|
$args['attachments_search_content'] = $sd['search_attachments_content'];
|
|
$args['attachments_search_caption'] = $sd['search_attachments_caption'];
|
|
$args['attachments_search_ids'] = $sd['search_attachments_ids'];
|
|
$args['attachments_cf_filters'] = $sd['search_attachments_cf_filters'];
|
|
$args['attachment_use_image'] = $sd['attachment_use_image'];
|
|
$args['attachment_link_to'] = $sd['attachment_link_to'];
|
|
$args['attachment_link_to_secondary'] = $sd['attachment_link_to_secondary'];
|
|
$args['attachment_pdf_image'] = $sd['attachment_pdf_image'];
|
|
|
|
$args['attachment_exclude_directories'] = $search_options->get('attachment_exclude_directories')->directories;
|
|
$args['attachment_include_directories'] = $search_options->get('attachment_include_directories')->directories;
|
|
|
|
if (
|
|
count($args['attachment_exclude_directories']) > 0 ||
|
|
count($args['attachment_include_directories']) > 0
|
|
) {
|
|
$uploads = wp_get_upload_dir();
|
|
if ( false === $uploads['error'] ) {
|
|
$uploads_relative_dir =
|
|
trailingslashit( str_replace(ABSPATH, '', $uploads['basedir']) );
|
|
$args['attachment_exclude_directories'] = array_filter(
|
|
array_map(
|
|
function ( $dir ) use ( $uploads_relative_dir ) {
|
|
return str_replace($uploads_relative_dir, '', $dir);
|
|
},
|
|
$args['attachment_exclude_directories']
|
|
)
|
|
);
|
|
$args['attachment_include_directories'] = array_filter(
|
|
array_map(
|
|
function ( $dir ) use ( $uploads_relative_dir ) {
|
|
return str_replace($uploads_relative_dir, '', $dir);
|
|
},
|
|
$args['attachment_include_directories']
|
|
)
|
|
);
|
|
}
|
|
|
|
if ( count($args['attachment_exclude_directories']) > 0 ) {
|
|
$args['attachments_cf_filters'] = true;
|
|
$args['post_meta_filter'][] = array(
|
|
'key' => '_wp_attached_file',
|
|
'value' => $args['attachment_exclude_directories'],
|
|
'operator' => 'NOT STARTS WITH',
|
|
'allow_missing' => true,
|
|
'logic' => 'AND',
|
|
);
|
|
}
|
|
|
|
if ( count($args['attachment_include_directories']) > 0 ) {
|
|
$args['attachments_cf_filters'] = true;
|
|
$args['post_meta_filter'][] = array(
|
|
'key' => '_wp_attached_file',
|
|
'value' => $args['attachment_include_directories'],
|
|
'operator' => 'STARTS WITH',
|
|
'allow_missing' => true,
|
|
'logic' => 'OR',
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------
|
|
// 3. BLOGS
|
|
// ----------------------------------------------------------------
|
|
if ( $sd['searchinblogtitles'] ) {
|
|
$args['search_type'][] = 'blogs';
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// 4. BUDDYPRESS
|
|
// ----------------------------------------------------------------
|
|
$args['bp_groups_search'] = $sd['search_in_bp_groups'];
|
|
$args['bp_groups_search_public'] = $sd['search_in_bp_groups_public'];
|
|
$args['bp_groups_search_private'] = $sd['search_in_bp_groups_private'];
|
|
$args['bp_groups_search_hidden'] = $sd['search_in_bp_groups_hidden'];
|
|
$args['bp_activities_search'] = $sd['search_in_bp_activities'];
|
|
if ( $args['bp_groups_search'] || $sd['search_in_bp_activities'] ) {
|
|
$args['search_type'][] = 'buddypress';
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// 5. COMMENTS
|
|
// ----------------------------------------------------------------
|
|
if ( $sd['searchincomments'] ) {
|
|
$args['search_type'][] = 'comments';
|
|
$args['comments_search'] = true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// 6. TAXONOMY TERMS
|
|
// ----------------------------------------------------------------
|
|
$args['taxonomy_include'] = array();
|
|
|
|
if ( $sd['return_categories'] ) {
|
|
$args['taxonomy_include'][] = 'category';
|
|
}
|
|
if ( $sd['return_tags'] ) {
|
|
$args['taxonomy_include'][] = 'post_tag';
|
|
}
|
|
if ( count(w_isset_def($sd['selected-return_terms'], array())) > 0 ) {
|
|
$args['taxonomy_include'] = array_merge($args['taxonomy_include'], $sd['selected-return_terms']);
|
|
}
|
|
|
|
$args['taxonomy_terms_exclude'] =
|
|
is_array($sd['return_terms_exclude']) ?
|
|
$sd['return_terms_exclude'] :
|
|
array_filter(
|
|
explode(',', $sd['return_terms_exclude']),
|
|
function ( $el ) {
|
|
return !empty($el);
|
|
}
|
|
);
|
|
|
|
$args['taxonomy_terms_exclude_empty'] = $sd['return_terms_exclude_empty']; // exclude empty taxonomy terms
|
|
if ( count($args['taxonomy_include']) > 0 ) {
|
|
$args['search_type'][] = 'taxonomies';
|
|
}
|
|
$args['taxonomy_terms_search_titles'] = $sd['search_term_titles'];
|
|
$args['taxonomy_terms_search_description'] = $sd['search_term_descriptions'];
|
|
$args['taxonomy_terms_search_term_meta'] = $sd['search_term_meta'];
|
|
|
|
// ----------------------------------------------------------------
|
|
// 7. USERS results
|
|
// ----------------------------------------------------------------
|
|
if ( $sd['user_search'] ) {
|
|
$args['search_type'][] = 'users';
|
|
}
|
|
$args['user_login_search'] = $sd['user_login_search'];
|
|
$args['user_display_name_search'] = $sd['user_display_name_search'];
|
|
$args['user_first_name_search'] = $sd['user_first_name_search'];
|
|
$args['user_last_name_search'] = $sd['user_last_name_search'];
|
|
$args['user_bio_search'] = $sd['user_bio_search'];
|
|
$args['user_email_search'] = $sd['user_email_search'];
|
|
$args['user_search_meta_fields'] = $sd['user_search_meta_fields'];
|
|
$args['user_search_bp_fields'] = w_isset_def( $sd['selected-user_bp_fields'], array() );
|
|
$args['user_search_exclude_roles'] = w_isset_def( $sd['selected-user_search_exclude_roles'], array() );
|
|
if ( count($sd['user_search_exclude_users']['users']) ) {
|
|
foreach ( $sd['user_search_exclude_users']['users'] as $uk => $uv ) {
|
|
if ( intval($uv) === -2 ) {
|
|
$sd['user_search_exclude_users']['users'][ $uk ] = get_current_user_id();
|
|
}
|
|
}
|
|
if ( $sd['user_search_exclude_users']['op_type'] === 'exclude' ) {
|
|
$args['user_search_exclude_ids'] = $sd['user_search_exclude_users']['users'];
|
|
} else {
|
|
$args['user_search_include_ids'] = $sd['user_search_exclude_users']['users'];
|
|
}
|
|
}
|
|
$args['user_meta_filter'] = self::getCustomFieldArgs($sd, $o, 'usermeta');
|
|
/*------------------- Meta key order for user search -----------------*/
|
|
$args['user_primary_order'] = $sd['user_orderby_primary'];
|
|
$args['user_secondary_order'] = $sd['user_orderby_secondary'];
|
|
if ( strpos($sd['user_orderby_primary'], 'customfp') !== false ) {
|
|
if ( !empty($sd['user_orderby_primary_cf']) ) {
|
|
$args['_user_primary_order_metakey'] = $sd['user_orderby_primary_cf'];
|
|
$args['user_primary_order_metatype'] = $sd['user_orderby_primary_cf_type'];
|
|
}
|
|
}
|
|
if ( strpos($sd['user_orderby_secondary'], 'customfs') !== false ) {
|
|
if ( !empty($sd['user_orderby_secondary_cf']) ) {
|
|
$args['_user_secondary_order_metakey'] = $sd['user_orderby_secondary_cf'];
|
|
$args['user_secondary_order_metatype'] = $sd['user_orderby_secondary_cf_type'];
|
|
}
|
|
}
|
|
// ----------------------------------------------------------------
|
|
|
|
/*-------------------- FORCE CORRECT ORDERING -------------------*/
|
|
$correct_cpt_orders = array_unique(
|
|
array_merge(
|
|
SearchQueryArgs::SUPPORTED_PRIMARY_ORDERINGS,
|
|
SearchQueryArgs::SUPPORTED_SECONDARY_ORDERINGS,
|
|
)
|
|
);
|
|
$correct_user_orders = array_unique(
|
|
array_merge(
|
|
SearchQueryArgs::SUPPORTED_USER_PRIMARY_ORDERINGS,
|
|
SearchQueryArgs::SUPPORTED_USER_SECONDARY_ORDERINGS,
|
|
)
|
|
);
|
|
if ( !in_array($args['post_primary_order'], $correct_cpt_orders, true) ) {
|
|
$args['post_primary_order'] = 'relevance DESC';
|
|
}
|
|
if ( !in_array($args['post_secondary_order'], $correct_cpt_orders, true) ) {
|
|
$args['post_secondary_order'] = 'date DESC';
|
|
}
|
|
if ( !in_array($args['user_primary_order'], $correct_user_orders, true) ) {
|
|
$args['user_primary_order'] = 'relevance DESC';
|
|
}
|
|
if ( !in_array($args['user_secondary_order'], $correct_user_orders, true) ) {
|
|
$args['user_secondary_order'] = 'date DESC';
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// 8. Peepso Groups & Activities
|
|
// ----------------------------------------------------------------
|
|
if (
|
|
isset($sd['peep_gs_public']) &&
|
|
( $sd['peep_gs_public'] || $sd['peep_gs_closed'] || $sd['peep_gs_secret'] ) &&
|
|
( $sd['peep_gs_title'] || $sd['peep_gs_content'] || $sd['peep_gs_categories'] )
|
|
) {
|
|
$args['search_type'][] = 'peepso_groups';
|
|
if ( $sd['peep_gs_public'] ) {
|
|
$args['peepso_group_privacy'][] = 0;
|
|
}
|
|
if ( $sd['peep_gs_closed'] ) {
|
|
$args['peepso_group_privacy'][] = 1;
|
|
}
|
|
if ( $sd['peep_gs_secret'] ) {
|
|
$args['peepso_group_privacy'][] = 2;
|
|
}
|
|
if ( $sd['peep_gs_title'] ) {
|
|
$args['peepso_group_fields'][] = 'title';
|
|
}
|
|
if ( $sd['peep_gs_content'] ) {
|
|
$args['peepso_group_fields'][] = 'content';
|
|
}
|
|
if ( $sd['peep_gs_categories'] ) {
|
|
$args['peepso_group_fields'][] = 'categories';
|
|
}
|
|
|
|
$args['peepso_group_not_in'] = array_map('trim', explode(',', $sd['peep_gs_exclude']));
|
|
$args['peepso_groups_limit'] = $sd['peepso_groups_limit'];
|
|
$args['peepso_groups_limit_override'] = $sd['peepso_groups_limit_override'];
|
|
}
|
|
|
|
if ( isset($sd['peep_s_posts']) && ( $sd['peep_s_posts'] || $sd['peep_s_comments'] ) ) {
|
|
$args['search_type'][] = 'peepso_activities';
|
|
$args['peepso_activity_types'] = array();
|
|
if ( $sd['peep_s_posts'] ) {
|
|
$args['peepso_activity_types'][] = 'peepso-post';
|
|
}
|
|
if ( $sd['peep_s_comments'] ) {
|
|
$args['peepso_activity_types'][] = 'peepso-comment';
|
|
}
|
|
|
|
$args['peepso_activity_follow'] = $sd['peep_pc_follow'];
|
|
|
|
if ( $sd['peep_pc_public'] ) {
|
|
$args['peepso_group_activity_privacy'][] = 0;
|
|
}
|
|
if ( $sd['peep_pc_closed'] ) {
|
|
$args['peepso_group_activity_privacy'][] = 1;
|
|
}
|
|
if ( $sd['peep_pc_secret'] ) {
|
|
$args['peepso_group_activity_privacy'][] = 2;
|
|
}
|
|
|
|
$args['peepso_activities_limit'] = $sd['peepso_activities_limit'];
|
|
$args['peepso_activities_limit_override'] = $sd['peepso_activities_limit_override'];
|
|
}
|
|
// ----------------------------------------------------------------
|
|
|
|
// ----------------------------------------------------------------
|
|
// 9. Content Type filters
|
|
// ---------------------------------------------------------------
|
|
self::getContentTypeArgs($sd, $o, $args);
|
|
|
|
// ----------------------------------------------------------------
|
|
// 10. INDEX TABLE SEARCH
|
|
// ---------------------------------------------------------------
|
|
if ( $it_options['it_pool_size_auto'] ) {
|
|
$s_pool_s = Manager::suggestPoolSizes();
|
|
$args['it_pool_size_one'] = $s_pool_s['one'];
|
|
$args['it_pool_size_two'] = $s_pool_s['two'];
|
|
$args['it_pool_size_three'] = $s_pool_s['three'];
|
|
$args['it_pool_size_rest'] = $s_pool_s['rest'];
|
|
} else {
|
|
$args['it_pool_size_one'] = $it_options['it_pool_size_one'];
|
|
$args['it_pool_size_two'] = $it_options['it_pool_size_two'];
|
|
$args['it_pool_size_three'] = $it_options['it_pool_size_three'];
|
|
$args['it_pool_size_rest'] = $it_options['it_pool_size_rest'];
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// X. MISC FIXES
|
|
// ----------------------------------------------------------------
|
|
$args['_show_more_results'] = $sd['showmoreresults'];
|
|
$args['woo_currency'] = $o['woo_currency'] ?? ( function_exists('get_woocommerce_currency') ? get_woocommerce_currency() : '' );
|
|
$args['_page_id'] = intval($o['current_page_id'] ?? ( $args['_page_id'] ?? 0 ));
|
|
$args['_is_autopopulate'] = isset($_POST['autop']); // phpcs:ignore
|
|
|
|
$default_query_arr = array(
|
|
'fields' => '',
|
|
'join' => '',
|
|
'where' => '',
|
|
'orderby' => '',
|
|
'groupby' => 'title',
|
|
);
|
|
if ( $sd['groupby_cpt_title'] ) {
|
|
if ( !isset($args['cpt_query']) ) {
|
|
$args['cpt_query'] = $default_query_arr;
|
|
} else {
|
|
$args['cpt_query']['groupby'] = 'title';
|
|
}
|
|
}
|
|
if ( $sd['groupby_term_title'] ) {
|
|
if ( !isset($args['term_query']) ) {
|
|
$args['term_query'] = $default_query_arr;
|
|
} else {
|
|
$args['term_query']['groupby'] = 'title';
|
|
}
|
|
}
|
|
if ( $sd['groupby_user_title'] ) {
|
|
if ( !isset($args['user_query']) ) {
|
|
$args['user_query'] = $default_query_arr;
|
|
} else {
|
|
$args['user_query']['groupby'] = 'title';
|
|
}
|
|
}
|
|
if ( $sd['groupby_attachment_title'] ) {
|
|
if ( !isset($args['attachment_query']) ) {
|
|
$args['attachment_query'] = $default_query_arr;
|
|
} else {
|
|
$args['attachment_query']['groupby'] = 'title';
|
|
}
|
|
}
|
|
// ----------------------------------------------------------------
|
|
return $args;
|
|
}
|
|
|
|
|
|
/**
|
|
* Converts search data and options to Taxonomy Term query argument arrays to use with SearchQuery
|
|
*
|
|
* @param array<string, mixed> $sd
|
|
* @param array<string, mixed> $o
|
|
* @return array<int, mixed>
|
|
*/
|
|
private static function getTaxonomyArgs( array $sd, array $o ): array {
|
|
$ret = array();
|
|
|
|
if ( !isset( $o['termset'] ) || $o['termset'] === '' ) {
|
|
$o['termset'] = array();
|
|
}
|
|
|
|
$taxonomies = array();
|
|
|
|
// Excluded by terms (advanced option -> exclude results)
|
|
$sd_exclude = array();
|
|
foreach ( $sd['exclude_by_terms']['terms'] as $t ) {
|
|
if ( !in_array($t['taxonomy'], $taxonomies, true) ) {
|
|
$taxonomies[] = $t['taxonomy'];
|
|
}
|
|
|
|
if ( !isset($sd_exclude[ $t['taxonomy'] ]) ) {
|
|
$sd_exclude[ $t['taxonomy'] ] = array();
|
|
}
|
|
if ( intval($t['id']) === -1 ) {
|
|
$tt_terms = get_terms(
|
|
array(
|
|
'hide_empty' => false,
|
|
'fields' => 'ids',
|
|
'taxonomy' => $t['taxonomy'],
|
|
)
|
|
);
|
|
if ( !is_wp_error($tt_terms) ) {
|
|
$sd_exclude[ $t['taxonomy'] ] = $tt_terms;
|
|
}
|
|
} else {
|
|
$sd_exclude[ $t['taxonomy'] ][] = $t['id']; // @phpstan-ignore-line
|
|
}
|
|
}
|
|
|
|
// Include by terms (advanced option -> exclude results)
|
|
$sd_include = array();
|
|
foreach ( $sd['include_by_terms']['terms'] as $t ) {
|
|
if ( !in_array($t['taxonomy'], $taxonomies, true) ) {
|
|
$taxonomies[] = $t['taxonomy'];
|
|
}
|
|
|
|
if ( !isset($sd_include[ $t['taxonomy'] ]) ) {
|
|
$sd_include[ $t['taxonomy'] ] = array();
|
|
}
|
|
if ( intval($t['id']) === -1 ) {
|
|
$tt_terms = get_terms(
|
|
array(
|
|
'hide_empty' => false,
|
|
'fields' => 'ids',
|
|
'taxonomy' => $t['taxonomy'],
|
|
)
|
|
);
|
|
if ( !is_wp_error($tt_terms) ) {
|
|
$sd_include[ $t['taxonomy'] ] = $tt_terms;
|
|
}
|
|
} else {
|
|
$sd_include[ $t['taxonomy'] ][] = $t['id']; // @phpstan-ignore-line
|
|
}
|
|
}
|
|
|
|
if ( count( $sd['show_terms']['terms'] ) > 0 ||
|
|
count( $sd_exclude ) > 0 ||
|
|
count( $sd_include ) > 0 ||
|
|
count( $o['termset'] ) > 0 ||
|
|
isset($o['termset_single']) > 0
|
|
) {
|
|
// If the term settings are invisible, ignore the excluded frontend terms, reset to empty array
|
|
if ( !$sd['showsearchintaxonomies'] ) {
|
|
$sd['show_terms']['terms'] = array();
|
|
}
|
|
|
|
// First task is to get any taxonomy related
|
|
foreach ( $sd['show_terms']['terms'] as $t ) {
|
|
if ( !in_array($t['taxonomy'], $taxonomies, true) ) {
|
|
$taxonomies[] = $t['taxonomy'];
|
|
}
|
|
}
|
|
if ( count($o['termset']) ) {
|
|
foreach ( $o['termset'] as $taxonomy => $terms ) {
|
|
if ( !in_array($taxonomy, $taxonomies, true) ) {
|
|
$taxonomies[] = $taxonomy;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
// If no value is selected, transform it to an array
|
|
$option_set = $o['termset_single'] ?? ( !isset($o['termset'][ $taxonomy ]) ? array() : $o['termset'][ $taxonomy ] );
|
|
|
|
// If radio or drop is selected, convert it to array
|
|
$option_set =
|
|
!is_array( $option_set ) ? array( $option_set ) : $option_set;
|
|
|
|
if (
|
|
count( $option_set ) === 1 && in_array(-1, $option_set) && // phpcs:ignore
|
|
count( $sd_exclude ) === 0 // ...and there are no exclusions
|
|
) {
|
|
continue;
|
|
} elseif ( count($option_set) === 1 && in_array(-1, $option_set) ) { // phpcs:ignore
|
|
$option_set = array(); // Reset the options to empty, as '-1' won't work
|
|
|
|
}
|
|
|
|
$display_mode = 'checkboxes';
|
|
$term_logic = $sd['term_logic'];
|
|
$is_checkboxes = true;
|
|
// If not the checkboxes are used, and there is no forced inclusion, temporary force the OR logic
|
|
if ( count($sd['show_terms']['display_mode']) > 0 ) {
|
|
if ( isset($sd['show_terms']['display_mode'][ $taxonomy ]) ) {
|
|
if ( $sd['show_terms']['display_mode'][ $taxonomy ]['type'] !== 'checkboxes' ) {
|
|
// $term_logic = "or";
|
|
$display_mode = $sd['show_terms']['display_mode'][ $taxonomy ]['type'];
|
|
$is_checkboxes = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Gather the API terms
|
|
$api_terms = array();
|
|
$override_allow_empty = '';
|
|
foreach ( wd_asp()->front_filters->get('position', 'taxonomy') as $filter ) { // @phpstan-ignore-line
|
|
if ( $filter->is_api && $filter->data['taxonomy'] === $taxonomy ) {
|
|
$fterms = $filter->get();
|
|
foreach ( $fterms as $fterm ) {
|
|
if ( $fterm->id > 0 ) {
|
|
$api_terms[] = $fterm->id;
|
|
}
|
|
}
|
|
if ( count($api_terms) > 0 ) {
|
|
$is_checkboxes = $filter->display_mode === 'checkboxes';
|
|
if ( $filter->data['logic'] !== '' ) {
|
|
$term_logic = strtolower( $filter->data['logic'] );
|
|
}
|
|
if ( $filter->data['allow_empty'] !== '' ) {
|
|
$override_allow_empty = $filter->data['allow_empty'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Check if the term filters are visible for the user?
|
|
$term_filters_visible = count( $sd['show_terms']['terms'] ) > 0 || count($api_terms) > 0;
|
|
|
|
// If the term settings are invisible,
|
|
// ...or nothing is chosen, but filters are active
|
|
// ignore the excluded frontend terms, reset to empty array
|
|
$exclude_showterms = array();
|
|
if (
|
|
$term_filters_visible && ( !$sd['frontend_terms_ignore_empty'] || !empty($option_set) ) && $is_checkboxes
|
|
) {
|
|
foreach ( $sd['show_terms']['terms'] as $t ) {
|
|
if ( $t['taxonomy'] === $taxonomy ) {
|
|
if ( intval($t['id']) === -1 ) {
|
|
/**
|
|
* @var int[] $t_terms
|
|
*/
|
|
$t_terms = get_terms(
|
|
array(
|
|
'hide_empty' => false,
|
|
'fields' => 'ids',
|
|
'exclude' => $t['ex_ids'],
|
|
'taxonomy' => $taxonomy,
|
|
)
|
|
);
|
|
if ( $taxonomy === 'post_format' ) {
|
|
$t_terms[] = -200;
|
|
}
|
|
if ( !is_wp_error($t_terms) ) {
|
|
$exclude_showterms = array_merge($exclude_showterms, $t_terms);
|
|
}
|
|
} else {
|
|
$exclude_showterms[] = $t['id'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$exclude_showterms = array_unique( array_merge($exclude_showterms, $api_terms) );
|
|
$exclude_t = $sd_exclude[ $taxonomy ] ?? array();
|
|
|
|
// Force logic for checkbox and single drop-downs
|
|
if ( $display_mode === 'dropdown' || $display_mode === 'dropdownsearch' || $display_mode === 'radio' ) {
|
|
$term_logic = 'or';
|
|
}
|
|
|
|
$include_terms = array();
|
|
$exclude_terms = array();
|
|
|
|
/*
|
|
AND -> Posts NOT in an array of term ids
|
|
OR -> Posts in an array of term ids
|
|
*/
|
|
if ( $term_logic === 'and' ) {
|
|
if (
|
|
!( $is_checkboxes || !$term_filters_visible ) &&
|
|
!( $sd['frontend_terms_ignore_empty'] && empty($option_set) )
|
|
) {
|
|
$include_terms = count($option_set) === 0 ? array( -10 ) : $option_set;
|
|
if ( count($option_set) > 0 ) {
|
|
$term_logic = 'andex';
|
|
}
|
|
}
|
|
|
|
if ( $term_filters_visible ) {
|
|
$exclude_terms = array_diff( array_merge($exclude_t, $exclude_showterms), $option_set ); // @phpstan-ignore-line
|
|
} else {
|
|
$exclude_terms = $exclude_t;
|
|
}
|
|
} elseif ( $term_logic === 'or' || $term_logic === 'andex' ) {
|
|
$exclude_terms = $exclude_t;
|
|
if ( $term_filters_visible ) {
|
|
if ( !( $sd['frontend_terms_ignore_empty'] && empty($option_set) ) ) {
|
|
$include_terms = count( $option_set ) === 0 ? array( -10 ) : $option_set;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Manage inclusions from the back-end
|
|
if ( isset($sd_include[ $taxonomy ]) && count($sd_include[ $taxonomy ]) > 0 ) { // @phpstan-ignore-line
|
|
$include_terms = array_unique( array_merge($include_terms, $sd_include[ $taxonomy ]) ); // @phpstan-ignore-line
|
|
}
|
|
|
|
if ( !empty($include_terms) || !empty($exclude_terms) ) {
|
|
$add = array(
|
|
'taxonomy' => $taxonomy,
|
|
'include' => $include_terms,
|
|
'exclude' => $exclude_terms,
|
|
'logic' => $term_logic,
|
|
'_termset' => $o['termset'][ $taxonomy ] ?? array(),
|
|
'_is_checkbox' => $is_checkboxes,
|
|
);
|
|
if ( $override_allow_empty !== '' ) {
|
|
$add['allow_empty'] = $override_allow_empty;
|
|
}
|
|
// Include child terms of selected included terms
|
|
if ( $sd['frontend_terms_parent_child_assignment'] ) {
|
|
foreach ( $add['exclude'] as $term ) { // @phpstan-ignore-line
|
|
$children = get_term_children($term, $taxonomy);
|
|
if ( !is_wp_error($children) ) {
|
|
$add['exclude'] = array_merge($add['exclude'], $children); // @phpstan-ignore-line
|
|
}
|
|
}
|
|
foreach ( $add['include'] as $term ) {
|
|
$children = get_term_children($term, $taxonomy);
|
|
if ( !is_wp_error($children) ) {
|
|
$add['include'] = array_merge($add['include'], $children); // @phpstan-ignore-line
|
|
}
|
|
}
|
|
$add['include'] = array_diff(array_unique($add['include']), $add['exclude']); // @phpstan-ignore-line
|
|
}
|
|
$ret[] = $add;
|
|
}
|
|
}
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Converts search data and options to Tag query argument arrays to use with SearchQuery
|
|
*
|
|
* @param array<string, mixed> $sd
|
|
* @param array<string, mixed> $o
|
|
* @param array<string, mixed> $args
|
|
*/
|
|
private static function getTagArgs( array $sd, array $o, array &$args ): void {
|
|
|
|
// Get the tag options, by default the active param is enough, as it is disabled.
|
|
$st_options = w_isset_def( $sd['selected-show_frontend_tags'], array( 'active' => 0 ) );
|
|
$tag_logic = $sd['frontend_tags_logic'];
|
|
$no_tags_exist = false;
|
|
$exc_tags = w_isset_def( $sd['selected-exclude_post_tags'], array() );
|
|
|
|
$args['_post_tags_active'] = $st_options['active'];
|
|
$args['_post_tags_empty'] = $sd['frontend_tags_empty'];
|
|
|
|
$exclude_tags = array();
|
|
$include_tags = array();
|
|
|
|
if ( $st_options['active'] || count($exc_tags) > 0 ) {
|
|
// If no value is selected, transform it to an array
|
|
$o['post_tag_set'] = !isset($o['post_tag_set']) ? array() : $o['post_tag_set'];
|
|
// If radio or drop is selected, convert it to array
|
|
$o['post_tag_set'] =
|
|
!is_array( $o['post_tag_set'] ) ? array( $o['post_tag_set'] ) : $o['post_tag_set'];
|
|
|
|
// Is this the "All" option?
|
|
if (
|
|
count($o['post_tag_set']) === 1 &&
|
|
( in_array(-1, $o['post_tag_set']) || in_array(0, $o['post_tag_set']) ) || // phpcs:ignore
|
|
( $sd['frontend_terms_ignore_empty'] && empty($o['post_tag_set']) )
|
|
) {
|
|
if ( count($exc_tags) > 0 ) {
|
|
$args['post_tax_filter'][] = array(
|
|
'taxonomy' => 'post_tag',
|
|
'include' => $include_tags,
|
|
'exclude' => $exc_tags,
|
|
'allow_empty' => true, // Needs to be allowed, as otherwise posts with no tags will be hidden
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If not the checkboxes are used, force the OR logic
|
|
if ( $st_options['display_mode'] !== 'checkboxes' ) {
|
|
$tag_logic = 'or';
|
|
}
|
|
|
|
if ( $st_options['source'] === 'all' ) {
|
|
// Limit all tags to 500. I mean that should be more than enough...
|
|
$exclude_showtags = get_terms(
|
|
array(
|
|
'number' =>400,
|
|
'fields' =>'ids',
|
|
'taxonomy' => 'post_tag',
|
|
)
|
|
);
|
|
if ( is_wp_error($exclude_showtags) || count($exclude_showtags) === 0 ) { // @phpstan-ignore-line
|
|
$no_tags_exist = true;
|
|
}
|
|
} else {
|
|
$exclude_showtags = $st_options['tag_ids'];
|
|
}
|
|
|
|
/*
|
|
AND -> Posts NOT in an array of term ids
|
|
OR -> Posts in an array of term ids
|
|
*/
|
|
if ( $tag_logic === 'and' ) {
|
|
if ( $st_options['active'] ) {
|
|
$exclude_tags = array_diff( array_merge($exc_tags, $exclude_showtags), $o['post_tag_set'] );
|
|
} else {
|
|
$exclude_tags = $exc_tags;
|
|
}
|
|
} else {
|
|
$exclude_tags = $exc_tags;
|
|
|
|
// If there are no tags at all, then show all posts, because no filtering is required
|
|
if ( $no_tags_exist ) {
|
|
$include_tags = count($o['post_tag_set']) === 0 ? array() : $o['post_tag_set'];
|
|
} elseif ( $st_options['active'] ) {
|
|
$include_tags = count( $o['post_tag_set'] ) === 0 ? array( -10 ) : $o['post_tag_set'];
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @since 4.10
|
|
* Append to post tax filter to use, instead of separate query
|
|
*/
|
|
if ( count($exclude_tags) > 0 || count($include_tags) > 0 ) {
|
|
$args['post_tax_filter'][] = array(
|
|
'taxonomy' => 'post_tag',
|
|
'include' => $include_tags,
|
|
'exclude' => $exclude_tags,
|
|
'logic' => $tag_logic,
|
|
'_termset' => $o['post_tag_set'],
|
|
'_is_checkbox' => $st_options['display_mode'] === 'checkboxes',
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts search data and options to Custom Field query argument arrays to use with SearchQuery
|
|
*
|
|
* @param array<string, mixed> $sd
|
|
* @param array<string, mixed> $o
|
|
* @param 'all'|'postmeta'|'usermeta' $source Meta sources
|
|
* @return array<int, mixed>
|
|
* @noinspection PhpUnusedParameterInspection
|
|
*/
|
|
private static function getCustomFieldArgs( array $sd, array $o, string $source = 'postmeta' ): array {
|
|
|
|
$meta_fields = array();
|
|
|
|
if ( !isset( $o['aspf'] ) ) {
|
|
return $meta_fields;
|
|
}
|
|
|
|
foreach ( wd_asp()->front_filters->get('position', 'custom_field') as $filter ) { // @phpstan-ignore-line
|
|
if ( $source !== 'all' && $filter->data['source'] !== $source ) {
|
|
continue;
|
|
}
|
|
$unique_field = $filter->getUniqueFieldName( true );
|
|
|
|
// Field is missing, continue
|
|
if ( !isset($o['aspf'][ $unique_field ]) ) {
|
|
continue;
|
|
}
|
|
|
|
/**
|
|
* @var string|string[] $posted
|
|
*/
|
|
$posted = Str::escape( $o['aspf'][ $unique_field ] );
|
|
// Select2 script issue - empty item will not show up in select2, so this fake value is used
|
|
if ( $posted === '__any__' ) {
|
|
$posted = '';
|
|
}
|
|
|
|
// NULL (empty) values accept
|
|
if ( $posted === '' && $filter->type() !== 'hidden' ) {
|
|
continue;
|
|
}
|
|
|
|
// Manage the posted values first, in case these are multiple values
|
|
if ( is_array($posted) ) {
|
|
// The order is important for the range slider
|
|
if ( isset($posted['lower'], $posted['upper']) ) {
|
|
$posted = array( $posted['lower'], $posted['upper'] );
|
|
} else {
|
|
$posted = array_values($posted);
|
|
}
|
|
$add_posted = array();
|
|
foreach ( $posted as $pk => $pv ) {
|
|
// Multiple values passed separated by :: -> convert them to array
|
|
if ( strpos($pv, '::') !== false ) {
|
|
$pv = array_filter(array_map('trim', explode('::', $pv)));
|
|
if ( !empty($pv) ) {
|
|
// Memorize the new values, and remove the old
|
|
$add_posted = array_merge($add_posted, $pv);
|
|
unset($posted[ $pk ]);
|
|
}
|
|
}
|
|
}
|
|
// Old values were removed, add the new ones to the old array
|
|
if ( count($add_posted) > 0 ) {
|
|
$posted = array_unique( array_merge($posted, $add_posted) );
|
|
}
|
|
} elseif ( is_string($posted) ) {
|
|
// Multiple values passed separated by :: -> convert them to array
|
|
if ( strpos($posted, '::') !== false ) {
|
|
$posted = array_filter(array_map('trim', explode('::', $posted)));
|
|
}
|
|
}
|
|
|
|
if ( isset( $filter->data['operator'] ) ) {
|
|
switch ( strtolower($filter->data['operator']) ) {
|
|
case 'neq':
|
|
case '<>':
|
|
$operator = '<>';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'lt':
|
|
case '<':
|
|
$operator = '<';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'let':
|
|
case '<=':
|
|
$operator = '<=';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'gt':
|
|
case '>':
|
|
$operator = '>';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'get':
|
|
case '>=':
|
|
$operator = '>=';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'between':
|
|
$operator = is_array($posted) ? 'BETWEEN' : '=';
|
|
if ( is_array($posted) && isset($posted[0], $posted[1]) ) {
|
|
if ( $posted[0] === '' && $posted[1] === '' ) {
|
|
continue 2;
|
|
} elseif ( $posted[0] === '' ) {
|
|
$operator = '<=';
|
|
$posted = $posted[1];
|
|
} elseif ( $posted[1] === '' ) {
|
|
$operator = '>=';
|
|
$posted = $posted[0];
|
|
}
|
|
}
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
case 'not elike':
|
|
$operator = 'NOT ELIKE';
|
|
break;
|
|
case 'elike':
|
|
$operator = 'ELIKE';
|
|
break;
|
|
case 'not like':
|
|
$operator = 'NOT LIKE';
|
|
break;
|
|
case 'like':
|
|
$operator = 'LIKE';
|
|
break;
|
|
case 'in':
|
|
$operator = 'IN';
|
|
break;
|
|
case 'match':
|
|
$operator = '=';
|
|
break;
|
|
case 'nomatch':
|
|
$operator = '<>';
|
|
break;
|
|
case 'before':
|
|
$operator = '<';
|
|
break;
|
|
case 'before_inc':
|
|
$operator = '<=';
|
|
break;
|
|
case 'after':
|
|
$operator = '>';
|
|
break;
|
|
case 'after_inc':
|
|
$operator = '>=';
|
|
break;
|
|
default:
|
|
$operator = '=';
|
|
$posted = Str::forceNumeric( $posted );
|
|
break;
|
|
}
|
|
} else {
|
|
$operator = '=';
|
|
$posted = Str::forceNumeric( $posted );
|
|
}
|
|
|
|
if ( $filter->display_mode === 'range' ) {
|
|
$operator = 'BETWEEN';
|
|
}
|
|
|
|
if ( $filter->display_mode === 'range' || $filter->display_mode === 'slider' ) {
|
|
$posted = Str::forceNumeric($posted);
|
|
}
|
|
|
|
if ( $filter->display_mode === 'datepicker' ) {
|
|
|
|
switch ( w_isset_def($filter->data['date_store_format'], 'acf') ) {
|
|
case 'datetime':
|
|
/**
|
|
* Format YY MM DD is accepted by strtotime as ISO8601 Notation
|
|
* http://php.net/manual/en/datetime.formats.date.php
|
|
*/
|
|
$posted = strtotime($posted, time());
|
|
$posted = date('Y-m-d', $posted); // phpcs:ignore
|
|
$operator = 'datetime ' . $operator;
|
|
break;
|
|
case 'timestamp':
|
|
$posted = strtotime($posted, time());
|
|
$operator = 'timestamp ' . $operator;
|
|
break;
|
|
default:
|
|
/**
|
|
* This is ACF aka. yymmdd aka. 20170101
|
|
* ...so the operators need to be adjusted in cases of < and > to <= and >=
|
|
*/
|
|
$posted = preg_replace('/[^0-9]/', '', $posted);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Simplifications
|
|
if ( is_array($posted) && count($posted) > 2 ) {
|
|
if ( $operator === '=' ) {
|
|
$operator = 'IN';
|
|
}
|
|
}
|
|
|
|
// Data type for JSON serialized objects - like ACF storage
|
|
if (
|
|
$filter->data['acf_type'] !== false
|
|
) {
|
|
if (
|
|
in_array($filter->data['acf_type'], array( 'multiselect', 'checkbox' ), true) &&
|
|
in_array($operator, array( 'ELIKE', 'NOT ELIKE', 'IN' ), true)
|
|
) {
|
|
$operator = str_replace('ELIKE', 'LIKE', $operator);
|
|
if ( is_array($posted) ) {
|
|
foreach ( $posted as &$pv ) {
|
|
$pv = ':"' . $pv . '";';
|
|
}
|
|
unset($pv);
|
|
} else {
|
|
$posted = ':"' . $posted . '";';
|
|
}
|
|
}
|
|
|
|
if ( $filter->data['acf_type'] === 'post_object' ) {
|
|
$operator = 'ACF_POST_OBJECT';
|
|
}
|
|
}
|
|
|
|
$arr = array(
|
|
'key' => $filter->data['field'],
|
|
'value' => $posted,
|
|
'operator' => $operator,
|
|
'logic_and_separate_custom_fields' => $filter->data['logic_and_separate_custom_fields'],
|
|
);
|
|
if ( !empty($filter->data['logic']) ) {
|
|
$arr['logic'] = strtolower( trim($filter->data['logic']) ) === 'and' ? 'AND' : 'OR';
|
|
}
|
|
$meta_fields[] = $arr;
|
|
}
|
|
return $meta_fields;
|
|
}
|
|
|
|
/**
|
|
* Converts search data and options to Date query argument arrays to use with SearchQuery
|
|
*
|
|
* @param array<string, mixed> $sd
|
|
* @param array<string, mixed> $o
|
|
* @return array<int, mixed>
|
|
*/
|
|
private static function getDateArgs( array $sd, array $o ): array {
|
|
$date_parts = array();
|
|
if ( $sd['exclude_dates_on'] ) {
|
|
$exc_dates = &$sd['selected-exclude_dates'];
|
|
if ( $exc_dates['from'] !== 'disabled' ) {
|
|
if ( $exc_dates['from'] === 'date' ) {
|
|
$exc_from_d = $exc_dates['fromDate'];
|
|
} else {
|
|
$str_to_time = strtotime(
|
|
' ' . ( -1 ) * $exc_dates['fromInt'][0] . ' year ' . ( -1 ) * $exc_dates['fromInt'][1] . ' month ' . ( -1 ) * $exc_dates['fromInt'][2] . ' day',
|
|
time()
|
|
);
|
|
$exc_from_d = date(
|
|
'y-m-d',
|
|
$str_to_time === false ? time() : $str_to_time
|
|
);
|
|
}
|
|
$date_parts[] = array(
|
|
'date' => $exc_from_d,
|
|
'operator' => $exc_dates['mode'],
|
|
'interval' => 'after',
|
|
);
|
|
}
|
|
if ( $exc_dates['to'] !== 'disabled' ) {
|
|
if ( $exc_dates['to'] === 'date' ) {
|
|
$exc_to_d = $exc_dates['toDate'];
|
|
} else {
|
|
$str_to_time = strtotime(
|
|
' ' . ( -1 ) * $exc_dates['toInt'][0] . ' year ' . ( -1 ) * $exc_dates['toInt'][1] . ' month ' . ( -1 ) * $exc_dates['toInt'][2] . ' day',
|
|
time()
|
|
);
|
|
$exc_to_d = date(
|
|
'y-m-d',
|
|
$str_to_time === false ? time() : $str_to_time
|
|
);
|
|
}
|
|
$date_parts[] = array(
|
|
'date' => $exc_to_d,
|
|
'operator' => $exc_dates['mode'],
|
|
'interval' => 'before',
|
|
);
|
|
}
|
|
}
|
|
|
|
// Filters from front-end
|
|
if ( !empty($o['post_date_from']) && Str::checkDate($o['post_date_from']) ) {
|
|
// preg_match("/(\d+)\-(\d+)\-(\d+)$/", $o['post_date_from'], $m);
|
|
$date_parts[] = array(
|
|
'date' => $o['post_date_from'],
|
|
'operator' => 'include',
|
|
'interval' => 'after',
|
|
);
|
|
}
|
|
|
|
if ( !empty($o['post_date_to']) && Str::checkDate($o['post_date_to']) ) {
|
|
// preg_match("/(\d+)\-(\d+)\-(\d+)$/", $o['post_date_to'], $m);
|
|
$date_parts[] = array(
|
|
'date' => $o['post_date_to'],
|
|
'operator' => 'include',
|
|
'interval' => 'before',
|
|
);
|
|
}
|
|
|
|
return $date_parts;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param array<string, mixed> $sd
|
|
* @param array<string, mixed> $o
|
|
* @param array<string, mixed> $args
|
|
* @return void
|
|
*/
|
|
private static function getContentTypeArgs( array $sd, array $o, array &$args ): void {
|
|
$ctf = $sd['content_type_filter'];
|
|
if ( count($ctf['selected']) > 0 ) {
|
|
$o['asp_ctf'] = !isset($o['asp_ctf']) ? array() : $o['asp_ctf'];
|
|
$o['asp_ctf'] = !is_array($o['asp_ctf']) ? array( $o['asp_ctf'] ) : $o['asp_ctf'];
|
|
if ( $ctf['display_mode'] === 'checkboxes' ) {
|
|
$unchecked = array_diff($ctf['selected'], $o['asp_ctf']);
|
|
$args['search_type'] = array_diff($args['search_type'], $unchecked);
|
|
} elseif ( !in_array(-1, $o['asp_ctf']) ) { // phpcs:ignore
|
|
// Only if 'Choose any' is not selected
|
|
$args['search_type'] = array_intersect($args['search_type'], $o['asp_ctf']);
|
|
}
|
|
}
|
|
}
|
|
}
|